@aws-sdk/client-backup 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 +634 -1286
  2. package/dist-es/protocols/Aws_restJson1.js +635 -1287
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,102 +1,73 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { BackupServiceException as __BaseException } from "../models/BackupServiceException";
5
5
  import { AlreadyExistsException, ConflictException, DependencyFailureException, InvalidParameterValueException, InvalidRequestException, InvalidResourceStateException, LimitExceededException, MissingParameterValueException, ResourceNotFoundException, ServiceUnavailableException, } from "../models/models_0";
6
6
  export const se_CancelLegalHoldCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = {};
9
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/legal-holds/{LegalHoldId}";
10
- resolvedPath = __resolvedPath(resolvedPath, input, "LegalHoldId", () => input.LegalHoldId, "{LegalHoldId}", false);
9
+ b.bp("/legal-holds/{LegalHoldId}");
10
+ b.p("LegalHoldId", () => input.LegalHoldId, "{LegalHoldId}", false);
11
11
  const query = map({
12
- cancelDescription: [, __expectNonNull(input.CancelDescription, `CancelDescription`)],
13
- retainRecordInDays: [() => input.RetainRecordInDays !== void 0, () => input.RetainRecordInDays.toString()],
12
+ [_cD]: [, __expectNonNull(input[_CD], `CancelDescription`)],
13
+ [_rRID]: [() => input.RetainRecordInDays !== void 0, () => input[_RRID].toString()],
14
14
  });
15
15
  let body;
16
- return new __HttpRequest({
17
- protocol,
18
- hostname,
19
- port,
20
- method: "DELETE",
21
- headers,
22
- path: resolvedPath,
23
- query,
24
- body,
25
- });
16
+ b.m("DELETE").h(headers).q(query).b(body);
17
+ return b.build();
26
18
  };
27
19
  export const se_CreateBackupPlanCommand = async (input, context) => {
28
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
20
+ const b = rb(input, context);
29
21
  const headers = {
30
22
  "content-type": "application/json",
31
23
  };
32
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans";
24
+ b.bp("/backup/plans");
33
25
  let body;
34
26
  body = JSON.stringify(take(input, {
35
27
  BackupPlan: (_) => _json(_),
36
28
  BackupPlanTags: (_) => _json(_),
37
29
  CreatorRequestId: [],
38
30
  }));
39
- return new __HttpRequest({
40
- protocol,
41
- hostname,
42
- port,
43
- method: "PUT",
44
- headers,
45
- path: resolvedPath,
46
- body,
47
- });
31
+ b.m("PUT").h(headers).b(body);
32
+ return b.build();
48
33
  };
49
34
  export const se_CreateBackupSelectionCommand = async (input, context) => {
50
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
35
+ const b = rb(input, context);
51
36
  const headers = {
52
37
  "content-type": "application/json",
53
38
  };
54
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}/selections";
55
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
39
+ b.bp("/backup/plans/{BackupPlanId}/selections");
40
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
56
41
  let body;
57
42
  body = JSON.stringify(take(input, {
58
43
  BackupSelection: (_) => _json(_),
59
44
  CreatorRequestId: [],
60
45
  }));
61
- return new __HttpRequest({
62
- protocol,
63
- hostname,
64
- port,
65
- method: "PUT",
66
- headers,
67
- path: resolvedPath,
68
- body,
69
- });
46
+ b.m("PUT").h(headers).b(body);
47
+ return b.build();
70
48
  };
71
49
  export const se_CreateBackupVaultCommand = async (input, context) => {
72
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
50
+ const b = rb(input, context);
73
51
  const headers = {
74
52
  "content-type": "application/json",
75
53
  };
76
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-vaults/{BackupVaultName}";
77
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
54
+ b.bp("/backup-vaults/{BackupVaultName}");
55
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
78
56
  let body;
79
57
  body = JSON.stringify(take(input, {
80
58
  BackupVaultTags: (_) => _json(_),
81
59
  CreatorRequestId: [],
82
60
  EncryptionKeyArn: [],
83
61
  }));
84
- return new __HttpRequest({
85
- protocol,
86
- hostname,
87
- port,
88
- method: "PUT",
89
- headers,
90
- path: resolvedPath,
91
- body,
92
- });
62
+ b.m("PUT").h(headers).b(body);
63
+ return b.build();
93
64
  };
94
65
  export const se_CreateFrameworkCommand = async (input, context) => {
95
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
66
+ const b = rb(input, context);
96
67
  const headers = {
97
68
  "content-type": "application/json",
98
69
  };
99
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/frameworks";
70
+ b.bp("/audit/frameworks");
100
71
  let body;
101
72
  body = JSON.stringify(take(input, {
102
73
  FrameworkControls: (_) => _json(_),
@@ -105,22 +76,15 @@ export const se_CreateFrameworkCommand = async (input, context) => {
105
76
  FrameworkTags: (_) => _json(_),
106
77
  IdempotencyToken: [true, (_) => _ ?? generateIdempotencyToken()],
107
78
  }));
108
- return new __HttpRequest({
109
- protocol,
110
- hostname,
111
- port,
112
- method: "POST",
113
- headers,
114
- path: resolvedPath,
115
- body,
116
- });
79
+ b.m("POST").h(headers).b(body);
80
+ return b.build();
117
81
  };
118
82
  export const se_CreateLegalHoldCommand = async (input, context) => {
119
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
83
+ const b = rb(input, context);
120
84
  const headers = {
121
85
  "content-type": "application/json",
122
86
  };
123
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/legal-holds";
87
+ b.bp("/legal-holds");
124
88
  let body;
125
89
  body = JSON.stringify(take(input, {
126
90
  Description: [],
@@ -129,24 +93,16 @@ export const se_CreateLegalHoldCommand = async (input, context) => {
129
93
  Tags: (_) => _json(_),
130
94
  Title: [],
131
95
  }));
132
- return new __HttpRequest({
133
- protocol,
134
- hostname,
135
- port,
136
- method: "POST",
137
- headers,
138
- path: resolvedPath,
139
- body,
140
- });
96
+ b.m("POST").h(headers).b(body);
97
+ return b.build();
141
98
  };
142
99
  export const se_CreateLogicallyAirGappedBackupVaultCommand = async (input, context) => {
143
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
100
+ const b = rb(input, context);
144
101
  const headers = {
145
102
  "content-type": "application/json",
146
103
  };
147
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
148
- "/logically-air-gapped-backup-vaults/{BackupVaultName}";
149
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
104
+ b.bp("/logically-air-gapped-backup-vaults/{BackupVaultName}");
105
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
150
106
  let body;
151
107
  body = JSON.stringify(take(input, {
152
108
  BackupVaultTags: (_) => _json(_),
@@ -154,22 +110,15 @@ export const se_CreateLogicallyAirGappedBackupVaultCommand = async (input, conte
154
110
  MaxRetentionDays: [],
155
111
  MinRetentionDays: [],
156
112
  }));
157
- return new __HttpRequest({
158
- protocol,
159
- hostname,
160
- port,
161
- method: "PUT",
162
- headers,
163
- path: resolvedPath,
164
- body,
165
- });
113
+ b.m("PUT").h(headers).b(body);
114
+ return b.build();
166
115
  };
167
116
  export const se_CreateReportPlanCommand = async (input, context) => {
168
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
117
+ const b = rb(input, context);
169
118
  const headers = {
170
119
  "content-type": "application/json",
171
120
  };
172
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-plans";
121
+ b.bp("/audit/report-plans");
173
122
  let body;
174
123
  body = JSON.stringify(take(input, {
175
124
  IdempotencyToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -179,1432 +128,871 @@ export const se_CreateReportPlanCommand = async (input, context) => {
179
128
  ReportPlanTags: (_) => _json(_),
180
129
  ReportSetting: (_) => _json(_),
181
130
  }));
182
- return new __HttpRequest({
183
- protocol,
184
- hostname,
185
- port,
186
- method: "POST",
187
- headers,
188
- path: resolvedPath,
189
- body,
190
- });
131
+ b.m("POST").h(headers).b(body);
132
+ return b.build();
191
133
  };
192
134
  export const se_CreateRestoreTestingPlanCommand = async (input, context) => {
193
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
135
+ const b = rb(input, context);
194
136
  const headers = {
195
137
  "content-type": "application/json",
196
138
  };
197
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-testing/plans";
139
+ b.bp("/restore-testing/plans");
198
140
  let body;
199
141
  body = JSON.stringify(take(input, {
200
142
  CreatorRequestId: [],
201
143
  RestoreTestingPlan: (_) => _json(_),
202
144
  Tags: (_) => _json(_),
203
145
  }));
204
- return new __HttpRequest({
205
- protocol,
206
- hostname,
207
- port,
208
- method: "PUT",
209
- headers,
210
- path: resolvedPath,
211
- body,
212
- });
146
+ b.m("PUT").h(headers).b(body);
147
+ return b.build();
213
148
  };
214
149
  export const se_CreateRestoreTestingSelectionCommand = async (input, context) => {
215
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
150
+ const b = rb(input, context);
216
151
  const headers = {
217
152
  "content-type": "application/json",
218
153
  };
219
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
220
- "/restore-testing/plans/{RestoreTestingPlanName}/selections";
221
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
154
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}/selections");
155
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
222
156
  let body;
223
157
  body = JSON.stringify(take(input, {
224
158
  CreatorRequestId: [],
225
159
  RestoreTestingSelection: (_) => _json(_),
226
160
  }));
227
- return new __HttpRequest({
228
- protocol,
229
- hostname,
230
- port,
231
- method: "PUT",
232
- headers,
233
- path: resolvedPath,
234
- body,
235
- });
161
+ b.m("PUT").h(headers).b(body);
162
+ return b.build();
236
163
  };
237
164
  export const se_DeleteBackupPlanCommand = async (input, context) => {
238
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
165
+ const b = rb(input, context);
239
166
  const headers = {};
240
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}";
241
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
167
+ b.bp("/backup/plans/{BackupPlanId}");
168
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
242
169
  let body;
243
- return new __HttpRequest({
244
- protocol,
245
- hostname,
246
- port,
247
- method: "DELETE",
248
- headers,
249
- path: resolvedPath,
250
- body,
251
- });
170
+ b.m("DELETE").h(headers).b(body);
171
+ return b.build();
252
172
  };
253
173
  export const se_DeleteBackupSelectionCommand = async (input, context) => {
254
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
174
+ const b = rb(input, context);
255
175
  const headers = {};
256
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
257
- "/backup/plans/{BackupPlanId}/selections/{SelectionId}";
258
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
259
- resolvedPath = __resolvedPath(resolvedPath, input, "SelectionId", () => input.SelectionId, "{SelectionId}", false);
176
+ b.bp("/backup/plans/{BackupPlanId}/selections/{SelectionId}");
177
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
178
+ b.p("SelectionId", () => input.SelectionId, "{SelectionId}", false);
260
179
  let body;
261
- return new __HttpRequest({
262
- protocol,
263
- hostname,
264
- port,
265
- method: "DELETE",
266
- headers,
267
- path: resolvedPath,
268
- body,
269
- });
180
+ b.m("DELETE").h(headers).b(body);
181
+ return b.build();
270
182
  };
271
183
  export const se_DeleteBackupVaultCommand = async (input, context) => {
272
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
184
+ const b = rb(input, context);
273
185
  const headers = {};
274
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-vaults/{BackupVaultName}";
275
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
186
+ b.bp("/backup-vaults/{BackupVaultName}");
187
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
276
188
  let body;
277
- return new __HttpRequest({
278
- protocol,
279
- hostname,
280
- port,
281
- method: "DELETE",
282
- headers,
283
- path: resolvedPath,
284
- body,
285
- });
189
+ b.m("DELETE").h(headers).b(body);
190
+ return b.build();
286
191
  };
287
192
  export const se_DeleteBackupVaultAccessPolicyCommand = async (input, context) => {
288
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
193
+ const b = rb(input, context);
289
194
  const headers = {};
290
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
291
- "/backup-vaults/{BackupVaultName}/access-policy";
292
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
195
+ b.bp("/backup-vaults/{BackupVaultName}/access-policy");
196
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
293
197
  let body;
294
- return new __HttpRequest({
295
- protocol,
296
- hostname,
297
- port,
298
- method: "DELETE",
299
- headers,
300
- path: resolvedPath,
301
- body,
302
- });
198
+ b.m("DELETE").h(headers).b(body);
199
+ return b.build();
303
200
  };
304
201
  export const se_DeleteBackupVaultLockConfigurationCommand = async (input, context) => {
305
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
202
+ const b = rb(input, context);
306
203
  const headers = {};
307
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
308
- "/backup-vaults/{BackupVaultName}/vault-lock";
309
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
204
+ b.bp("/backup-vaults/{BackupVaultName}/vault-lock");
205
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
310
206
  let body;
311
- return new __HttpRequest({
312
- protocol,
313
- hostname,
314
- port,
315
- method: "DELETE",
316
- headers,
317
- path: resolvedPath,
318
- body,
319
- });
207
+ b.m("DELETE").h(headers).b(body);
208
+ return b.build();
320
209
  };
321
210
  export const se_DeleteBackupVaultNotificationsCommand = async (input, context) => {
322
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
211
+ const b = rb(input, context);
323
212
  const headers = {};
324
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
325
- "/backup-vaults/{BackupVaultName}/notification-configuration";
326
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
213
+ b.bp("/backup-vaults/{BackupVaultName}/notification-configuration");
214
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
327
215
  let body;
328
- return new __HttpRequest({
329
- protocol,
330
- hostname,
331
- port,
332
- method: "DELETE",
333
- headers,
334
- path: resolvedPath,
335
- body,
336
- });
216
+ b.m("DELETE").h(headers).b(body);
217
+ return b.build();
337
218
  };
338
219
  export const se_DeleteFrameworkCommand = async (input, context) => {
339
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
220
+ const b = rb(input, context);
340
221
  const headers = {};
341
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/frameworks/{FrameworkName}";
342
- resolvedPath = __resolvedPath(resolvedPath, input, "FrameworkName", () => input.FrameworkName, "{FrameworkName}", false);
222
+ b.bp("/audit/frameworks/{FrameworkName}");
223
+ b.p("FrameworkName", () => input.FrameworkName, "{FrameworkName}", false);
343
224
  let body;
344
- return new __HttpRequest({
345
- protocol,
346
- hostname,
347
- port,
348
- method: "DELETE",
349
- headers,
350
- path: resolvedPath,
351
- body,
352
- });
225
+ b.m("DELETE").h(headers).b(body);
226
+ return b.build();
353
227
  };
354
228
  export const se_DeleteRecoveryPointCommand = async (input, context) => {
355
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
229
+ const b = rb(input, context);
356
230
  const headers = {};
357
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
358
- "/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}";
359
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
360
- resolvedPath = __resolvedPath(resolvedPath, input, "RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
231
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}");
232
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
233
+ b.p("RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
361
234
  let body;
362
- return new __HttpRequest({
363
- protocol,
364
- hostname,
365
- port,
366
- method: "DELETE",
367
- headers,
368
- path: resolvedPath,
369
- body,
370
- });
235
+ b.m("DELETE").h(headers).b(body);
236
+ return b.build();
371
237
  };
372
238
  export const se_DeleteReportPlanCommand = async (input, context) => {
373
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
239
+ const b = rb(input, context);
374
240
  const headers = {};
375
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-plans/{ReportPlanName}";
376
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
241
+ b.bp("/audit/report-plans/{ReportPlanName}");
242
+ b.p("ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
377
243
  let body;
378
- return new __HttpRequest({
379
- protocol,
380
- hostname,
381
- port,
382
- method: "DELETE",
383
- headers,
384
- path: resolvedPath,
385
- body,
386
- });
244
+ b.m("DELETE").h(headers).b(body);
245
+ return b.build();
387
246
  };
388
247
  export const se_DeleteRestoreTestingPlanCommand = async (input, context) => {
389
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
248
+ const b = rb(input, context);
390
249
  const headers = {};
391
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
392
- "/restore-testing/plans/{RestoreTestingPlanName}";
393
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
250
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}");
251
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
394
252
  let body;
395
- return new __HttpRequest({
396
- protocol,
397
- hostname,
398
- port,
399
- method: "DELETE",
400
- headers,
401
- path: resolvedPath,
402
- body,
403
- });
253
+ b.m("DELETE").h(headers).b(body);
254
+ return b.build();
404
255
  };
405
256
  export const se_DeleteRestoreTestingSelectionCommand = async (input, context) => {
406
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
257
+ const b = rb(input, context);
407
258
  const headers = {};
408
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
409
- "/restore-testing/plans/{RestoreTestingPlanName}/selections/{RestoreTestingSelectionName}";
410
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
411
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingSelectionName", () => input.RestoreTestingSelectionName, "{RestoreTestingSelectionName}", false);
259
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}/selections/{RestoreTestingSelectionName}");
260
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
261
+ b.p("RestoreTestingSelectionName", () => input.RestoreTestingSelectionName, "{RestoreTestingSelectionName}", false);
412
262
  let body;
413
- return new __HttpRequest({
414
- protocol,
415
- hostname,
416
- port,
417
- method: "DELETE",
418
- headers,
419
- path: resolvedPath,
420
- body,
421
- });
263
+ b.m("DELETE").h(headers).b(body);
264
+ return b.build();
422
265
  };
423
266
  export const se_DescribeBackupJobCommand = async (input, context) => {
424
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
267
+ const b = rb(input, context);
425
268
  const headers = {};
426
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-jobs/{BackupJobId}";
427
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupJobId", () => input.BackupJobId, "{BackupJobId}", false);
269
+ b.bp("/backup-jobs/{BackupJobId}");
270
+ b.p("BackupJobId", () => input.BackupJobId, "{BackupJobId}", false);
428
271
  let body;
429
- return new __HttpRequest({
430
- protocol,
431
- hostname,
432
- port,
433
- method: "GET",
434
- headers,
435
- path: resolvedPath,
436
- body,
437
- });
272
+ b.m("GET").h(headers).b(body);
273
+ return b.build();
438
274
  };
439
275
  export const se_DescribeBackupVaultCommand = async (input, context) => {
440
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
276
+ const b = rb(input, context);
441
277
  const headers = {};
442
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-vaults/{BackupVaultName}";
443
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
278
+ b.bp("/backup-vaults/{BackupVaultName}");
279
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
444
280
  const query = map({
445
- backupVaultAccountId: [, input.BackupVaultAccountId],
281
+ [_bVAI]: [, input[_BVAI]],
446
282
  });
447
283
  let body;
448
- return new __HttpRequest({
449
- protocol,
450
- hostname,
451
- port,
452
- method: "GET",
453
- headers,
454
- path: resolvedPath,
455
- query,
456
- body,
457
- });
284
+ b.m("GET").h(headers).q(query).b(body);
285
+ return b.build();
458
286
  };
459
287
  export const se_DescribeCopyJobCommand = async (input, context) => {
460
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
288
+ const b = rb(input, context);
461
289
  const headers = {};
462
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/copy-jobs/{CopyJobId}";
463
- resolvedPath = __resolvedPath(resolvedPath, input, "CopyJobId", () => input.CopyJobId, "{CopyJobId}", false);
290
+ b.bp("/copy-jobs/{CopyJobId}");
291
+ b.p("CopyJobId", () => input.CopyJobId, "{CopyJobId}", false);
464
292
  let body;
465
- return new __HttpRequest({
466
- protocol,
467
- hostname,
468
- port,
469
- method: "GET",
470
- headers,
471
- path: resolvedPath,
472
- body,
473
- });
293
+ b.m("GET").h(headers).b(body);
294
+ return b.build();
474
295
  };
475
296
  export const se_DescribeFrameworkCommand = async (input, context) => {
476
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
297
+ const b = rb(input, context);
477
298
  const headers = {};
478
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/frameworks/{FrameworkName}";
479
- resolvedPath = __resolvedPath(resolvedPath, input, "FrameworkName", () => input.FrameworkName, "{FrameworkName}", false);
299
+ b.bp("/audit/frameworks/{FrameworkName}");
300
+ b.p("FrameworkName", () => input.FrameworkName, "{FrameworkName}", false);
480
301
  let body;
481
- return new __HttpRequest({
482
- protocol,
483
- hostname,
484
- port,
485
- method: "GET",
486
- headers,
487
- path: resolvedPath,
488
- body,
489
- });
302
+ b.m("GET").h(headers).b(body);
303
+ return b.build();
490
304
  };
491
305
  export const se_DescribeGlobalSettingsCommand = async (input, context) => {
492
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
306
+ const b = rb(input, context);
493
307
  const headers = {
494
308
  "content-type": "application/json",
495
309
  };
496
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-settings";
310
+ b.bp("/global-settings");
497
311
  let body;
498
312
  body = "";
499
- return new __HttpRequest({
500
- protocol,
501
- hostname,
502
- port,
503
- method: "GET",
504
- headers,
505
- path: resolvedPath,
506
- body,
507
- });
313
+ b.m("GET").h(headers).b(body);
314
+ return b.build();
508
315
  };
509
316
  export const se_DescribeProtectedResourceCommand = async (input, context) => {
510
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
317
+ const b = rb(input, context);
511
318
  const headers = {};
512
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resources/{ResourceArn}";
513
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
319
+ b.bp("/resources/{ResourceArn}");
320
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
514
321
  let body;
515
- return new __HttpRequest({
516
- protocol,
517
- hostname,
518
- port,
519
- method: "GET",
520
- headers,
521
- path: resolvedPath,
522
- body,
523
- });
322
+ b.m("GET").h(headers).b(body);
323
+ return b.build();
524
324
  };
525
325
  export const se_DescribeRecoveryPointCommand = async (input, context) => {
526
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
326
+ const b = rb(input, context);
527
327
  const headers = {};
528
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
529
- "/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}";
530
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
531
- resolvedPath = __resolvedPath(resolvedPath, input, "RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
328
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}");
329
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
330
+ b.p("RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
532
331
  const query = map({
533
- backupVaultAccountId: [, input.BackupVaultAccountId],
332
+ [_bVAI]: [, input[_BVAI]],
534
333
  });
535
334
  let body;
536
- return new __HttpRequest({
537
- protocol,
538
- hostname,
539
- port,
540
- method: "GET",
541
- headers,
542
- path: resolvedPath,
543
- query,
544
- body,
545
- });
335
+ b.m("GET").h(headers).q(query).b(body);
336
+ return b.build();
546
337
  };
547
338
  export const se_DescribeRegionSettingsCommand = async (input, context) => {
548
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
339
+ const b = rb(input, context);
549
340
  const headers = {
550
341
  "content-type": "application/json",
551
342
  };
552
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account-settings";
343
+ b.bp("/account-settings");
553
344
  let body;
554
345
  body = "";
555
- return new __HttpRequest({
556
- protocol,
557
- hostname,
558
- port,
559
- method: "GET",
560
- headers,
561
- path: resolvedPath,
562
- body,
563
- });
346
+ b.m("GET").h(headers).b(body);
347
+ return b.build();
564
348
  };
565
349
  export const se_DescribeReportJobCommand = async (input, context) => {
566
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
350
+ const b = rb(input, context);
567
351
  const headers = {};
568
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-jobs/{ReportJobId}";
569
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportJobId", () => input.ReportJobId, "{ReportJobId}", false);
352
+ b.bp("/audit/report-jobs/{ReportJobId}");
353
+ b.p("ReportJobId", () => input.ReportJobId, "{ReportJobId}", false);
570
354
  let body;
571
- return new __HttpRequest({
572
- protocol,
573
- hostname,
574
- port,
575
- method: "GET",
576
- headers,
577
- path: resolvedPath,
578
- body,
579
- });
355
+ b.m("GET").h(headers).b(body);
356
+ return b.build();
580
357
  };
581
358
  export const se_DescribeReportPlanCommand = async (input, context) => {
582
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
359
+ const b = rb(input, context);
583
360
  const headers = {};
584
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-plans/{ReportPlanName}";
585
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
361
+ b.bp("/audit/report-plans/{ReportPlanName}");
362
+ b.p("ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
586
363
  let body;
587
- return new __HttpRequest({
588
- protocol,
589
- hostname,
590
- port,
591
- method: "GET",
592
- headers,
593
- path: resolvedPath,
594
- body,
595
- });
364
+ b.m("GET").h(headers).b(body);
365
+ return b.build();
596
366
  };
597
367
  export const se_DescribeRestoreJobCommand = async (input, context) => {
598
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
368
+ const b = rb(input, context);
599
369
  const headers = {};
600
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-jobs/{RestoreJobId}";
601
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreJobId", () => input.RestoreJobId, "{RestoreJobId}", false);
370
+ b.bp("/restore-jobs/{RestoreJobId}");
371
+ b.p("RestoreJobId", () => input.RestoreJobId, "{RestoreJobId}", false);
602
372
  let body;
603
- return new __HttpRequest({
604
- protocol,
605
- hostname,
606
- port,
607
- method: "GET",
608
- headers,
609
- path: resolvedPath,
610
- body,
611
- });
373
+ b.m("GET").h(headers).b(body);
374
+ return b.build();
612
375
  };
613
376
  export const se_DisassociateRecoveryPointCommand = async (input, context) => {
614
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
377
+ const b = rb(input, context);
615
378
  const headers = {};
616
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
617
- "/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}/disassociate";
618
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
619
- resolvedPath = __resolvedPath(resolvedPath, input, "RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
379
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}/disassociate");
380
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
381
+ b.p("RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
620
382
  let body;
621
- return new __HttpRequest({
622
- protocol,
623
- hostname,
624
- port,
625
- method: "POST",
626
- headers,
627
- path: resolvedPath,
628
- body,
629
- });
383
+ b.m("POST").h(headers).b(body);
384
+ return b.build();
630
385
  };
631
386
  export const se_DisassociateRecoveryPointFromParentCommand = async (input, context) => {
632
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
387
+ const b = rb(input, context);
633
388
  const headers = {};
634
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
635
- "/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}/parentAssociation";
636
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
637
- resolvedPath = __resolvedPath(resolvedPath, input, "RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
389
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}/parentAssociation");
390
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
391
+ b.p("RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
638
392
  let body;
639
- return new __HttpRequest({
640
- protocol,
641
- hostname,
642
- port,
643
- method: "DELETE",
644
- headers,
645
- path: resolvedPath,
646
- body,
647
- });
393
+ b.m("DELETE").h(headers).b(body);
394
+ return b.build();
648
395
  };
649
396
  export const se_ExportBackupPlanTemplateCommand = async (input, context) => {
650
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
397
+ const b = rb(input, context);
651
398
  const headers = {};
652
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}/toTemplate";
653
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
399
+ b.bp("/backup/plans/{BackupPlanId}/toTemplate");
400
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
654
401
  let body;
655
- return new __HttpRequest({
656
- protocol,
657
- hostname,
658
- port,
659
- method: "GET",
660
- headers,
661
- path: resolvedPath,
662
- body,
663
- });
402
+ b.m("GET").h(headers).b(body);
403
+ return b.build();
664
404
  };
665
405
  export const se_GetBackupPlanCommand = async (input, context) => {
666
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
406
+ const b = rb(input, context);
667
407
  const headers = {};
668
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}";
669
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
408
+ b.bp("/backup/plans/{BackupPlanId}");
409
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
670
410
  const query = map({
671
- versionId: [, input.VersionId],
411
+ [_vI]: [, input[_VI]],
672
412
  });
673
413
  let body;
674
- return new __HttpRequest({
675
- protocol,
676
- hostname,
677
- port,
678
- method: "GET",
679
- headers,
680
- path: resolvedPath,
681
- query,
682
- body,
683
- });
414
+ b.m("GET").h(headers).q(query).b(body);
415
+ return b.build();
684
416
  };
685
417
  export const se_GetBackupPlanFromJSONCommand = async (input, context) => {
686
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
418
+ const b = rb(input, context);
687
419
  const headers = {
688
420
  "content-type": "application/json",
689
421
  };
690
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/template/json/toPlan";
422
+ b.bp("/backup/template/json/toPlan");
691
423
  let body;
692
424
  body = JSON.stringify(take(input, {
693
425
  BackupPlanTemplateJson: [],
694
426
  }));
695
- return new __HttpRequest({
696
- protocol,
697
- hostname,
698
- port,
699
- method: "POST",
700
- headers,
701
- path: resolvedPath,
702
- body,
703
- });
427
+ b.m("POST").h(headers).b(body);
428
+ return b.build();
704
429
  };
705
430
  export const se_GetBackupPlanFromTemplateCommand = async (input, context) => {
706
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
431
+ const b = rb(input, context);
707
432
  const headers = {};
708
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
709
- "/backup/template/plans/{BackupPlanTemplateId}/toPlan";
710
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanTemplateId", () => input.BackupPlanTemplateId, "{BackupPlanTemplateId}", false);
433
+ b.bp("/backup/template/plans/{BackupPlanTemplateId}/toPlan");
434
+ b.p("BackupPlanTemplateId", () => input.BackupPlanTemplateId, "{BackupPlanTemplateId}", false);
711
435
  let body;
712
- return new __HttpRequest({
713
- protocol,
714
- hostname,
715
- port,
716
- method: "GET",
717
- headers,
718
- path: resolvedPath,
719
- body,
720
- });
436
+ b.m("GET").h(headers).b(body);
437
+ return b.build();
721
438
  };
722
439
  export const se_GetBackupSelectionCommand = async (input, context) => {
723
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
440
+ const b = rb(input, context);
724
441
  const headers = {};
725
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
726
- "/backup/plans/{BackupPlanId}/selections/{SelectionId}";
727
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
728
- resolvedPath = __resolvedPath(resolvedPath, input, "SelectionId", () => input.SelectionId, "{SelectionId}", false);
442
+ b.bp("/backup/plans/{BackupPlanId}/selections/{SelectionId}");
443
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
444
+ b.p("SelectionId", () => input.SelectionId, "{SelectionId}", false);
729
445
  let body;
730
- return new __HttpRequest({
731
- protocol,
732
- hostname,
733
- port,
734
- method: "GET",
735
- headers,
736
- path: resolvedPath,
737
- body,
738
- });
446
+ b.m("GET").h(headers).b(body);
447
+ return b.build();
739
448
  };
740
449
  export const se_GetBackupVaultAccessPolicyCommand = async (input, context) => {
741
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
450
+ const b = rb(input, context);
742
451
  const headers = {};
743
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
744
- "/backup-vaults/{BackupVaultName}/access-policy";
745
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
452
+ b.bp("/backup-vaults/{BackupVaultName}/access-policy");
453
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
746
454
  let body;
747
- return new __HttpRequest({
748
- protocol,
749
- hostname,
750
- port,
751
- method: "GET",
752
- headers,
753
- path: resolvedPath,
754
- body,
755
- });
455
+ b.m("GET").h(headers).b(body);
456
+ return b.build();
756
457
  };
757
458
  export const se_GetBackupVaultNotificationsCommand = async (input, context) => {
758
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
459
+ const b = rb(input, context);
759
460
  const headers = {};
760
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
761
- "/backup-vaults/{BackupVaultName}/notification-configuration";
762
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
461
+ b.bp("/backup-vaults/{BackupVaultName}/notification-configuration");
462
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
763
463
  let body;
764
- return new __HttpRequest({
765
- protocol,
766
- hostname,
767
- port,
768
- method: "GET",
769
- headers,
770
- path: resolvedPath,
771
- body,
772
- });
464
+ b.m("GET").h(headers).b(body);
465
+ return b.build();
773
466
  };
774
467
  export const se_GetLegalHoldCommand = async (input, context) => {
775
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
468
+ const b = rb(input, context);
776
469
  const headers = {};
777
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/legal-holds/{LegalHoldId}";
778
- resolvedPath = __resolvedPath(resolvedPath, input, "LegalHoldId", () => input.LegalHoldId, "{LegalHoldId}", false);
470
+ b.bp("/legal-holds/{LegalHoldId}");
471
+ b.p("LegalHoldId", () => input.LegalHoldId, "{LegalHoldId}", false);
779
472
  let body;
780
- return new __HttpRequest({
781
- protocol,
782
- hostname,
783
- port,
784
- method: "GET",
785
- headers,
786
- path: resolvedPath,
787
- body,
788
- });
473
+ b.m("GET").h(headers).b(body);
474
+ return b.build();
789
475
  };
790
476
  export const se_GetRecoveryPointRestoreMetadataCommand = async (input, context) => {
791
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
477
+ const b = rb(input, context);
792
478
  const headers = {};
793
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
794
- "/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}/restore-metadata";
795
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
796
- resolvedPath = __resolvedPath(resolvedPath, input, "RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
479
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}/restore-metadata");
480
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
481
+ b.p("RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
797
482
  const query = map({
798
- backupVaultAccountId: [, input.BackupVaultAccountId],
483
+ [_bVAI]: [, input[_BVAI]],
799
484
  });
800
485
  let body;
801
- return new __HttpRequest({
802
- protocol,
803
- hostname,
804
- port,
805
- method: "GET",
806
- headers,
807
- path: resolvedPath,
808
- query,
809
- body,
810
- });
486
+ b.m("GET").h(headers).q(query).b(body);
487
+ return b.build();
811
488
  };
812
489
  export const se_GetRestoreJobMetadataCommand = async (input, context) => {
813
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
490
+ const b = rb(input, context);
814
491
  const headers = {};
815
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-jobs/{RestoreJobId}/metadata";
816
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreJobId", () => input.RestoreJobId, "{RestoreJobId}", false);
492
+ b.bp("/restore-jobs/{RestoreJobId}/metadata");
493
+ b.p("RestoreJobId", () => input.RestoreJobId, "{RestoreJobId}", false);
817
494
  let body;
818
- return new __HttpRequest({
819
- protocol,
820
- hostname,
821
- port,
822
- method: "GET",
823
- headers,
824
- path: resolvedPath,
825
- body,
826
- });
495
+ b.m("GET").h(headers).b(body);
496
+ return b.build();
827
497
  };
828
498
  export const se_GetRestoreTestingInferredMetadataCommand = async (input, context) => {
829
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
499
+ const b = rb(input, context);
830
500
  const headers = {};
831
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-testing/inferred-metadata";
501
+ b.bp("/restore-testing/inferred-metadata");
832
502
  const query = map({
833
- BackupVaultAccountId: [, input.BackupVaultAccountId],
834
- BackupVaultName: [, __expectNonNull(input.BackupVaultName, `BackupVaultName`)],
835
- RecoveryPointArn: [, __expectNonNull(input.RecoveryPointArn, `RecoveryPointArn`)],
503
+ [_BVAI]: [, input[_BVAI]],
504
+ [_BVN]: [, __expectNonNull(input[_BVN], `BackupVaultName`)],
505
+ [_RPA]: [, __expectNonNull(input[_RPA], `RecoveryPointArn`)],
836
506
  });
837
507
  let body;
838
- return new __HttpRequest({
839
- protocol,
840
- hostname,
841
- port,
842
- method: "GET",
843
- headers,
844
- path: resolvedPath,
845
- query,
846
- body,
847
- });
508
+ b.m("GET").h(headers).q(query).b(body);
509
+ return b.build();
848
510
  };
849
511
  export const se_GetRestoreTestingPlanCommand = async (input, context) => {
850
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
512
+ const b = rb(input, context);
851
513
  const headers = {};
852
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
853
- "/restore-testing/plans/{RestoreTestingPlanName}";
854
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
514
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}");
515
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
855
516
  let body;
856
- return new __HttpRequest({
857
- protocol,
858
- hostname,
859
- port,
860
- method: "GET",
861
- headers,
862
- path: resolvedPath,
863
- body,
864
- });
517
+ b.m("GET").h(headers).b(body);
518
+ return b.build();
865
519
  };
866
520
  export const se_GetRestoreTestingSelectionCommand = async (input, context) => {
867
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
521
+ const b = rb(input, context);
868
522
  const headers = {};
869
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
870
- "/restore-testing/plans/{RestoreTestingPlanName}/selections/{RestoreTestingSelectionName}";
871
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
872
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingSelectionName", () => input.RestoreTestingSelectionName, "{RestoreTestingSelectionName}", false);
523
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}/selections/{RestoreTestingSelectionName}");
524
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
525
+ b.p("RestoreTestingSelectionName", () => input.RestoreTestingSelectionName, "{RestoreTestingSelectionName}", false);
873
526
  let body;
874
- return new __HttpRequest({
875
- protocol,
876
- hostname,
877
- port,
878
- method: "GET",
879
- headers,
880
- path: resolvedPath,
881
- body,
882
- });
527
+ b.m("GET").h(headers).b(body);
528
+ return b.build();
883
529
  };
884
530
  export const se_GetSupportedResourceTypesCommand = async (input, context) => {
885
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
531
+ const b = rb(input, context);
886
532
  const headers = {
887
533
  "content-type": "application/json",
888
534
  };
889
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/supported-resource-types";
535
+ b.bp("/supported-resource-types");
890
536
  let body;
891
537
  body = "";
892
- return new __HttpRequest({
893
- protocol,
894
- hostname,
895
- port,
896
- method: "GET",
897
- headers,
898
- path: resolvedPath,
899
- body,
900
- });
538
+ b.m("GET").h(headers).b(body);
539
+ return b.build();
901
540
  };
902
541
  export const se_ListBackupJobsCommand = async (input, context) => {
903
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
542
+ const b = rb(input, context);
904
543
  const headers = {};
905
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-jobs";
544
+ b.bp("/backup-jobs");
906
545
  const query = map({
907
- nextToken: [, input.NextToken],
908
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
909
- resourceArn: [, input.ByResourceArn],
910
- state: [, input.ByState],
911
- backupVaultName: [, input.ByBackupVaultName],
912
- createdBefore: [
913
- () => input.ByCreatedBefore !== void 0,
914
- () => (input.ByCreatedBefore.toISOString().split(".")[0] + "Z").toString(),
915
- ],
916
- createdAfter: [
917
- () => input.ByCreatedAfter !== void 0,
918
- () => (input.ByCreatedAfter.toISOString().split(".")[0] + "Z").toString(),
919
- ],
920
- resourceType: [, input.ByResourceType],
921
- accountId: [, input.ByAccountId],
922
- completeAfter: [
546
+ [_nT]: [, input[_NT]],
547
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
548
+ [_rA]: [, input[_BRA]],
549
+ [_s]: [, input[_BS]],
550
+ [_bVN]: [, input[_BBVN]],
551
+ [_cB]: [() => input.ByCreatedBefore !== void 0, () => (input[_BCB].toISOString().split(".")[0] + "Z").toString()],
552
+ [_cA]: [() => input.ByCreatedAfter !== void 0, () => (input[_BCA].toISOString().split(".")[0] + "Z").toString()],
553
+ [_rT]: [, input[_BRT]],
554
+ [_aI]: [, input[_BAI]],
555
+ [_cAo]: [
923
556
  () => input.ByCompleteAfter !== void 0,
924
- () => (input.ByCompleteAfter.toISOString().split(".")[0] + "Z").toString(),
557
+ () => (input[_BCAy].toISOString().split(".")[0] + "Z").toString(),
925
558
  ],
926
- completeBefore: [
559
+ [_cBo]: [
927
560
  () => input.ByCompleteBefore !== void 0,
928
- () => (input.ByCompleteBefore.toISOString().split(".")[0] + "Z").toString(),
561
+ () => (input[_BCBy].toISOString().split(".")[0] + "Z").toString(),
929
562
  ],
930
- parentJobId: [, input.ByParentJobId],
931
- messageCategory: [, input.ByMessageCategory],
563
+ [_pJI]: [, input[_BPJI]],
564
+ [_mC]: [, input[_BMC]],
932
565
  });
933
566
  let body;
934
- return new __HttpRequest({
935
- protocol,
936
- hostname,
937
- port,
938
- method: "GET",
939
- headers,
940
- path: resolvedPath,
941
- query,
942
- body,
943
- });
567
+ b.m("GET").h(headers).q(query).b(body);
568
+ return b.build();
944
569
  };
945
570
  export const se_ListBackupJobSummariesCommand = async (input, context) => {
946
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
571
+ const b = rb(input, context);
947
572
  const headers = {};
948
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/backup-job-summaries";
573
+ b.bp("/audit/backup-job-summaries");
949
574
  const query = map({
950
- AccountId: [, input.AccountId],
951
- State: [, input.State],
952
- ResourceType: [, input.ResourceType],
953
- MessageCategory: [, input.MessageCategory],
954
- AggregationPeriod: [, input.AggregationPeriod],
955
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
956
- NextToken: [, input.NextToken],
575
+ [_AI]: [, input[_AI]],
576
+ [_S]: [, input[_S]],
577
+ [_RT]: [, input[_RT]],
578
+ [_MC]: [, input[_MC]],
579
+ [_AP]: [, input[_AP]],
580
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
581
+ [_NT]: [, input[_NT]],
957
582
  });
958
583
  let body;
959
- return new __HttpRequest({
960
- protocol,
961
- hostname,
962
- port,
963
- method: "GET",
964
- headers,
965
- path: resolvedPath,
966
- query,
967
- body,
968
- });
584
+ b.m("GET").h(headers).q(query).b(body);
585
+ return b.build();
969
586
  };
970
587
  export const se_ListBackupPlansCommand = async (input, context) => {
971
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
588
+ const b = rb(input, context);
972
589
  const headers = {};
973
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans";
590
+ b.bp("/backup/plans");
974
591
  const query = map({
975
- nextToken: [, input.NextToken],
976
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
977
- includeDeleted: [() => input.IncludeDeleted !== void 0, () => input.IncludeDeleted.toString()],
592
+ [_nT]: [, input[_NT]],
593
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
594
+ [_iD]: [() => input.IncludeDeleted !== void 0, () => input[_ID].toString()],
978
595
  });
979
596
  let body;
980
- return new __HttpRequest({
981
- protocol,
982
- hostname,
983
- port,
984
- method: "GET",
985
- headers,
986
- path: resolvedPath,
987
- query,
988
- body,
989
- });
597
+ b.m("GET").h(headers).q(query).b(body);
598
+ return b.build();
990
599
  };
991
600
  export const se_ListBackupPlanTemplatesCommand = async (input, context) => {
992
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
601
+ const b = rb(input, context);
993
602
  const headers = {};
994
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/template/plans";
603
+ b.bp("/backup/template/plans");
995
604
  const query = map({
996
- nextToken: [, input.NextToken],
997
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
605
+ [_nT]: [, input[_NT]],
606
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
998
607
  });
999
608
  let body;
1000
- return new __HttpRequest({
1001
- protocol,
1002
- hostname,
1003
- port,
1004
- method: "GET",
1005
- headers,
1006
- path: resolvedPath,
1007
- query,
1008
- body,
1009
- });
609
+ b.m("GET").h(headers).q(query).b(body);
610
+ return b.build();
1010
611
  };
1011
612
  export const se_ListBackupPlanVersionsCommand = async (input, context) => {
1012
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
613
+ const b = rb(input, context);
1013
614
  const headers = {};
1014
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}/versions";
1015
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
615
+ b.bp("/backup/plans/{BackupPlanId}/versions");
616
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
1016
617
  const query = map({
1017
- nextToken: [, input.NextToken],
1018
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
618
+ [_nT]: [, input[_NT]],
619
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1019
620
  });
1020
621
  let body;
1021
- return new __HttpRequest({
1022
- protocol,
1023
- hostname,
1024
- port,
1025
- method: "GET",
1026
- headers,
1027
- path: resolvedPath,
1028
- query,
1029
- body,
1030
- });
622
+ b.m("GET").h(headers).q(query).b(body);
623
+ return b.build();
1031
624
  };
1032
625
  export const se_ListBackupSelectionsCommand = async (input, context) => {
1033
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
626
+ const b = rb(input, context);
1034
627
  const headers = {};
1035
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}/selections";
1036
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
628
+ b.bp("/backup/plans/{BackupPlanId}/selections");
629
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
1037
630
  const query = map({
1038
- nextToken: [, input.NextToken],
1039
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
631
+ [_nT]: [, input[_NT]],
632
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1040
633
  });
1041
634
  let body;
1042
- return new __HttpRequest({
1043
- protocol,
1044
- hostname,
1045
- port,
1046
- method: "GET",
1047
- headers,
1048
- path: resolvedPath,
1049
- query,
1050
- body,
1051
- });
635
+ b.m("GET").h(headers).q(query).b(body);
636
+ return b.build();
1052
637
  };
1053
638
  export const se_ListBackupVaultsCommand = async (input, context) => {
1054
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
639
+ const b = rb(input, context);
1055
640
  const headers = {};
1056
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-vaults";
641
+ b.bp("/backup-vaults");
1057
642
  const query = map({
1058
- vaultType: [, input.ByVaultType],
1059
- shared: [() => input.ByShared !== void 0, () => input.ByShared.toString()],
1060
- nextToken: [, input.NextToken],
1061
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
643
+ [_vT]: [, input[_BVT]],
644
+ [_sh]: [() => input.ByShared !== void 0, () => input[_BSy].toString()],
645
+ [_nT]: [, input[_NT]],
646
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1062
647
  });
1063
648
  let body;
1064
- return new __HttpRequest({
1065
- protocol,
1066
- hostname,
1067
- port,
1068
- method: "GET",
1069
- headers,
1070
- path: resolvedPath,
1071
- query,
1072
- body,
1073
- });
649
+ b.m("GET").h(headers).q(query).b(body);
650
+ return b.build();
1074
651
  };
1075
652
  export const se_ListCopyJobsCommand = async (input, context) => {
1076
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
653
+ const b = rb(input, context);
1077
654
  const headers = {};
1078
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/copy-jobs";
655
+ b.bp("/copy-jobs");
1079
656
  const query = map({
1080
- nextToken: [, input.NextToken],
1081
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1082
- resourceArn: [, input.ByResourceArn],
1083
- state: [, input.ByState],
1084
- createdBefore: [
1085
- () => input.ByCreatedBefore !== void 0,
1086
- () => (input.ByCreatedBefore.toISOString().split(".")[0] + "Z").toString(),
1087
- ],
1088
- createdAfter: [
1089
- () => input.ByCreatedAfter !== void 0,
1090
- () => (input.ByCreatedAfter.toISOString().split(".")[0] + "Z").toString(),
1091
- ],
1092
- resourceType: [, input.ByResourceType],
1093
- destinationVaultArn: [, input.ByDestinationVaultArn],
1094
- accountId: [, input.ByAccountId],
1095
- completeBefore: [
657
+ [_nT]: [, input[_NT]],
658
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
659
+ [_rA]: [, input[_BRA]],
660
+ [_s]: [, input[_BS]],
661
+ [_cB]: [() => input.ByCreatedBefore !== void 0, () => (input[_BCB].toISOString().split(".")[0] + "Z").toString()],
662
+ [_cA]: [() => input.ByCreatedAfter !== void 0, () => (input[_BCA].toISOString().split(".")[0] + "Z").toString()],
663
+ [_rT]: [, input[_BRT]],
664
+ [_dVA]: [, input[_BDVA]],
665
+ [_aI]: [, input[_BAI]],
666
+ [_cBo]: [
1096
667
  () => input.ByCompleteBefore !== void 0,
1097
- () => (input.ByCompleteBefore.toISOString().split(".")[0] + "Z").toString(),
668
+ () => (input[_BCBy].toISOString().split(".")[0] + "Z").toString(),
1098
669
  ],
1099
- completeAfter: [
670
+ [_cAo]: [
1100
671
  () => input.ByCompleteAfter !== void 0,
1101
- () => (input.ByCompleteAfter.toISOString().split(".")[0] + "Z").toString(),
672
+ () => (input[_BCAy].toISOString().split(".")[0] + "Z").toString(),
1102
673
  ],
1103
- parentJobId: [, input.ByParentJobId],
1104
- messageCategory: [, input.ByMessageCategory],
674
+ [_pJI]: [, input[_BPJI]],
675
+ [_mC]: [, input[_BMC]],
1105
676
  });
1106
677
  let body;
1107
- return new __HttpRequest({
1108
- protocol,
1109
- hostname,
1110
- port,
1111
- method: "GET",
1112
- headers,
1113
- path: resolvedPath,
1114
- query,
1115
- body,
1116
- });
678
+ b.m("GET").h(headers).q(query).b(body);
679
+ return b.build();
1117
680
  };
1118
681
  export const se_ListCopyJobSummariesCommand = async (input, context) => {
1119
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
682
+ const b = rb(input, context);
1120
683
  const headers = {};
1121
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/copy-job-summaries";
684
+ b.bp("/audit/copy-job-summaries");
1122
685
  const query = map({
1123
- AccountId: [, input.AccountId],
1124
- State: [, input.State],
1125
- ResourceType: [, input.ResourceType],
1126
- MessageCategory: [, input.MessageCategory],
1127
- AggregationPeriod: [, input.AggregationPeriod],
1128
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1129
- NextToken: [, input.NextToken],
686
+ [_AI]: [, input[_AI]],
687
+ [_S]: [, input[_S]],
688
+ [_RT]: [, input[_RT]],
689
+ [_MC]: [, input[_MC]],
690
+ [_AP]: [, input[_AP]],
691
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
692
+ [_NT]: [, input[_NT]],
1130
693
  });
1131
694
  let body;
1132
- return new __HttpRequest({
1133
- protocol,
1134
- hostname,
1135
- port,
1136
- method: "GET",
1137
- headers,
1138
- path: resolvedPath,
1139
- query,
1140
- body,
1141
- });
695
+ b.m("GET").h(headers).q(query).b(body);
696
+ return b.build();
1142
697
  };
1143
698
  export const se_ListFrameworksCommand = async (input, context) => {
1144
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
699
+ const b = rb(input, context);
1145
700
  const headers = {};
1146
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/frameworks";
701
+ b.bp("/audit/frameworks");
1147
702
  const query = map({
1148
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1149
- NextToken: [, input.NextToken],
703
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
704
+ [_NT]: [, input[_NT]],
1150
705
  });
1151
706
  let body;
1152
- return new __HttpRequest({
1153
- protocol,
1154
- hostname,
1155
- port,
1156
- method: "GET",
1157
- headers,
1158
- path: resolvedPath,
1159
- query,
1160
- body,
1161
- });
707
+ b.m("GET").h(headers).q(query).b(body);
708
+ return b.build();
1162
709
  };
1163
710
  export const se_ListLegalHoldsCommand = async (input, context) => {
1164
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
711
+ const b = rb(input, context);
1165
712
  const headers = {};
1166
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/legal-holds";
713
+ b.bp("/legal-holds");
1167
714
  const query = map({
1168
- nextToken: [, input.NextToken],
1169
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
715
+ [_nT]: [, input[_NT]],
716
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1170
717
  });
1171
718
  let body;
1172
- return new __HttpRequest({
1173
- protocol,
1174
- hostname,
1175
- port,
1176
- method: "GET",
1177
- headers,
1178
- path: resolvedPath,
1179
- query,
1180
- body,
1181
- });
719
+ b.m("GET").h(headers).q(query).b(body);
720
+ return b.build();
1182
721
  };
1183
722
  export const se_ListProtectedResourcesCommand = async (input, context) => {
1184
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
723
+ const b = rb(input, context);
1185
724
  const headers = {};
1186
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resources";
725
+ b.bp("/resources");
1187
726
  const query = map({
1188
- nextToken: [, input.NextToken],
1189
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
727
+ [_nT]: [, input[_NT]],
728
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1190
729
  });
1191
730
  let body;
1192
- return new __HttpRequest({
1193
- protocol,
1194
- hostname,
1195
- port,
1196
- method: "GET",
1197
- headers,
1198
- path: resolvedPath,
1199
- query,
1200
- body,
1201
- });
731
+ b.m("GET").h(headers).q(query).b(body);
732
+ return b.build();
1202
733
  };
1203
734
  export const se_ListProtectedResourcesByBackupVaultCommand = async (input, context) => {
1204
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
735
+ const b = rb(input, context);
1205
736
  const headers = {};
1206
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1207
- "/backup-vaults/{BackupVaultName}/resources";
1208
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
737
+ b.bp("/backup-vaults/{BackupVaultName}/resources");
738
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1209
739
  const query = map({
1210
- backupVaultAccountId: [, input.BackupVaultAccountId],
1211
- nextToken: [, input.NextToken],
1212
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
740
+ [_bVAI]: [, input[_BVAI]],
741
+ [_nT]: [, input[_NT]],
742
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1213
743
  });
1214
744
  let body;
1215
- return new __HttpRequest({
1216
- protocol,
1217
- hostname,
1218
- port,
1219
- method: "GET",
1220
- headers,
1221
- path: resolvedPath,
1222
- query,
1223
- body,
1224
- });
745
+ b.m("GET").h(headers).q(query).b(body);
746
+ return b.build();
1225
747
  };
1226
748
  export const se_ListRecoveryPointsByBackupVaultCommand = async (input, context) => {
1227
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
749
+ const b = rb(input, context);
1228
750
  const headers = {};
1229
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1230
- "/backup-vaults/{BackupVaultName}/recovery-points";
1231
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
751
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points");
752
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1232
753
  const query = map({
1233
- backupVaultAccountId: [, input.BackupVaultAccountId],
1234
- nextToken: [, input.NextToken],
1235
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1236
- resourceArn: [, input.ByResourceArn],
1237
- resourceType: [, input.ByResourceType],
1238
- backupPlanId: [, input.ByBackupPlanId],
1239
- createdBefore: [
1240
- () => input.ByCreatedBefore !== void 0,
1241
- () => (input.ByCreatedBefore.toISOString().split(".")[0] + "Z").toString(),
1242
- ],
1243
- createdAfter: [
1244
- () => input.ByCreatedAfter !== void 0,
1245
- () => (input.ByCreatedAfter.toISOString().split(".")[0] + "Z").toString(),
1246
- ],
1247
- parentRecoveryPointArn: [, input.ByParentRecoveryPointArn],
754
+ [_bVAI]: [, input[_BVAI]],
755
+ [_nT]: [, input[_NT]],
756
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
757
+ [_rA]: [, input[_BRA]],
758
+ [_rT]: [, input[_BRT]],
759
+ [_bPI]: [, input[_BBPI]],
760
+ [_cB]: [() => input.ByCreatedBefore !== void 0, () => (input[_BCB].toISOString().split(".")[0] + "Z").toString()],
761
+ [_cA]: [() => input.ByCreatedAfter !== void 0, () => (input[_BCA].toISOString().split(".")[0] + "Z").toString()],
762
+ [_pRPA]: [, input[_BPRPA]],
1248
763
  });
1249
764
  let body;
1250
- return new __HttpRequest({
1251
- protocol,
1252
- hostname,
1253
- port,
1254
- method: "GET",
1255
- headers,
1256
- path: resolvedPath,
1257
- query,
1258
- body,
1259
- });
765
+ b.m("GET").h(headers).q(query).b(body);
766
+ return b.build();
1260
767
  };
1261
768
  export const se_ListRecoveryPointsByLegalHoldCommand = async (input, context) => {
1262
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
769
+ const b = rb(input, context);
1263
770
  const headers = {};
1264
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1265
- "/legal-holds/{LegalHoldId}/recovery-points";
1266
- resolvedPath = __resolvedPath(resolvedPath, input, "LegalHoldId", () => input.LegalHoldId, "{LegalHoldId}", false);
771
+ b.bp("/legal-holds/{LegalHoldId}/recovery-points");
772
+ b.p("LegalHoldId", () => input.LegalHoldId, "{LegalHoldId}", false);
1267
773
  const query = map({
1268
- nextToken: [, input.NextToken],
1269
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
774
+ [_nT]: [, input[_NT]],
775
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1270
776
  });
1271
777
  let body;
1272
- return new __HttpRequest({
1273
- protocol,
1274
- hostname,
1275
- port,
1276
- method: "GET",
1277
- headers,
1278
- path: resolvedPath,
1279
- query,
1280
- body,
1281
- });
778
+ b.m("GET").h(headers).q(query).b(body);
779
+ return b.build();
1282
780
  };
1283
781
  export const se_ListRecoveryPointsByResourceCommand = async (input, context) => {
1284
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
782
+ const b = rb(input, context);
1285
783
  const headers = {};
1286
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resources/{ResourceArn}/recovery-points";
1287
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
784
+ b.bp("/resources/{ResourceArn}/recovery-points");
785
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1288
786
  const query = map({
1289
- nextToken: [, input.NextToken],
1290
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
787
+ [_nT]: [, input[_NT]],
788
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1291
789
  });
1292
790
  let body;
1293
- return new __HttpRequest({
1294
- protocol,
1295
- hostname,
1296
- port,
1297
- method: "GET",
1298
- headers,
1299
- path: resolvedPath,
1300
- query,
1301
- body,
1302
- });
791
+ b.m("GET").h(headers).q(query).b(body);
792
+ return b.build();
1303
793
  };
1304
794
  export const se_ListReportJobsCommand = async (input, context) => {
1305
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
795
+ const b = rb(input, context);
1306
796
  const headers = {};
1307
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-jobs";
797
+ b.bp("/audit/report-jobs");
1308
798
  const query = map({
1309
- ReportPlanName: [, input.ByReportPlanName],
1310
- CreationBefore: [
799
+ [_RPN]: [, input[_BRPN]],
800
+ [_CB]: [
1311
801
  () => input.ByCreationBefore !== void 0,
1312
- () => (input.ByCreationBefore.toISOString().split(".")[0] + "Z").toString(),
802
+ () => (input[_BCByr].toISOString().split(".")[0] + "Z").toString(),
1313
803
  ],
1314
- CreationAfter: [
804
+ [_CA]: [
1315
805
  () => input.ByCreationAfter !== void 0,
1316
- () => (input.ByCreationAfter.toISOString().split(".")[0] + "Z").toString(),
806
+ () => (input[_BCAyr].toISOString().split(".")[0] + "Z").toString(),
1317
807
  ],
1318
- Status: [, input.ByStatus],
1319
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1320
- NextToken: [, input.NextToken],
808
+ [_St]: [, input[_BSyt]],
809
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
810
+ [_NT]: [, input[_NT]],
1321
811
  });
1322
812
  let body;
1323
- return new __HttpRequest({
1324
- protocol,
1325
- hostname,
1326
- port,
1327
- method: "GET",
1328
- headers,
1329
- path: resolvedPath,
1330
- query,
1331
- body,
1332
- });
813
+ b.m("GET").h(headers).q(query).b(body);
814
+ return b.build();
1333
815
  };
1334
816
  export const se_ListReportPlansCommand = async (input, context) => {
1335
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
817
+ const b = rb(input, context);
1336
818
  const headers = {};
1337
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-plans";
819
+ b.bp("/audit/report-plans");
1338
820
  const query = map({
1339
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1340
- NextToken: [, input.NextToken],
821
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
822
+ [_NT]: [, input[_NT]],
1341
823
  });
1342
824
  let body;
1343
- return new __HttpRequest({
1344
- protocol,
1345
- hostname,
1346
- port,
1347
- method: "GET",
1348
- headers,
1349
- path: resolvedPath,
1350
- query,
1351
- body,
1352
- });
825
+ b.m("GET").h(headers).q(query).b(body);
826
+ return b.build();
1353
827
  };
1354
828
  export const se_ListRestoreJobsCommand = async (input, context) => {
1355
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
829
+ const b = rb(input, context);
1356
830
  const headers = {};
1357
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-jobs";
831
+ b.bp("/restore-jobs");
1358
832
  const query = map({
1359
- nextToken: [, input.NextToken],
1360
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1361
- accountId: [, input.ByAccountId],
1362
- resourceType: [, input.ByResourceType],
1363
- createdBefore: [
1364
- () => input.ByCreatedBefore !== void 0,
1365
- () => (input.ByCreatedBefore.toISOString().split(".")[0] + "Z").toString(),
1366
- ],
1367
- createdAfter: [
1368
- () => input.ByCreatedAfter !== void 0,
1369
- () => (input.ByCreatedAfter.toISOString().split(".")[0] + "Z").toString(),
1370
- ],
1371
- status: [, input.ByStatus],
1372
- completeBefore: [
833
+ [_nT]: [, input[_NT]],
834
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
835
+ [_aI]: [, input[_BAI]],
836
+ [_rT]: [, input[_BRT]],
837
+ [_cB]: [() => input.ByCreatedBefore !== void 0, () => (input[_BCB].toISOString().split(".")[0] + "Z").toString()],
838
+ [_cA]: [() => input.ByCreatedAfter !== void 0, () => (input[_BCA].toISOString().split(".")[0] + "Z").toString()],
839
+ [_st]: [, input[_BSyt]],
840
+ [_cBo]: [
1373
841
  () => input.ByCompleteBefore !== void 0,
1374
- () => (input.ByCompleteBefore.toISOString().split(".")[0] + "Z").toString(),
842
+ () => (input[_BCBy].toISOString().split(".")[0] + "Z").toString(),
1375
843
  ],
1376
- completeAfter: [
844
+ [_cAo]: [
1377
845
  () => input.ByCompleteAfter !== void 0,
1378
- () => (input.ByCompleteAfter.toISOString().split(".")[0] + "Z").toString(),
846
+ () => (input[_BCAy].toISOString().split(".")[0] + "Z").toString(),
1379
847
  ],
1380
- restoreTestingPlanArn: [, input.ByRestoreTestingPlanArn],
848
+ [_rTPA]: [, input[_BRTPA]],
1381
849
  });
1382
850
  let body;
1383
- return new __HttpRequest({
1384
- protocol,
1385
- hostname,
1386
- port,
1387
- method: "GET",
1388
- headers,
1389
- path: resolvedPath,
1390
- query,
1391
- body,
1392
- });
851
+ b.m("GET").h(headers).q(query).b(body);
852
+ return b.build();
1393
853
  };
1394
854
  export const se_ListRestoreJobsByProtectedResourceCommand = async (input, context) => {
1395
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
855
+ const b = rb(input, context);
1396
856
  const headers = {};
1397
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resources/{ResourceArn}/restore-jobs";
1398
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
857
+ b.bp("/resources/{ResourceArn}/restore-jobs");
858
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1399
859
  const query = map({
1400
- status: [, input.ByStatus],
1401
- recoveryPointCreationDateAfter: [
860
+ [_st]: [, input[_BSyt]],
861
+ [_rPCDA]: [
1402
862
  () => input.ByRecoveryPointCreationDateAfter !== void 0,
1403
- () => (input.ByRecoveryPointCreationDateAfter.toISOString().split(".")[0] + "Z").toString(),
863
+ () => (input[_BRPCDA].toISOString().split(".")[0] + "Z").toString(),
1404
864
  ],
1405
- recoveryPointCreationDateBefore: [
865
+ [_rPCDB]: [
1406
866
  () => input.ByRecoveryPointCreationDateBefore !== void 0,
1407
- () => (input.ByRecoveryPointCreationDateBefore.toISOString().split(".")[0] + "Z").toString(),
867
+ () => (input[_BRPCDB].toISOString().split(".")[0] + "Z").toString(),
1408
868
  ],
1409
- nextToken: [, input.NextToken],
1410
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
869
+ [_nT]: [, input[_NT]],
870
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1411
871
  });
1412
872
  let body;
1413
- return new __HttpRequest({
1414
- protocol,
1415
- hostname,
1416
- port,
1417
- method: "GET",
1418
- headers,
1419
- path: resolvedPath,
1420
- query,
1421
- body,
1422
- });
873
+ b.m("GET").h(headers).q(query).b(body);
874
+ return b.build();
1423
875
  };
1424
876
  export const se_ListRestoreJobSummariesCommand = async (input, context) => {
1425
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
877
+ const b = rb(input, context);
1426
878
  const headers = {};
1427
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/restore-job-summaries";
879
+ b.bp("/audit/restore-job-summaries");
1428
880
  const query = map({
1429
- AccountId: [, input.AccountId],
1430
- State: [, input.State],
1431
- ResourceType: [, input.ResourceType],
1432
- AggregationPeriod: [, input.AggregationPeriod],
1433
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1434
- NextToken: [, input.NextToken],
881
+ [_AI]: [, input[_AI]],
882
+ [_S]: [, input[_S]],
883
+ [_RT]: [, input[_RT]],
884
+ [_AP]: [, input[_AP]],
885
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
886
+ [_NT]: [, input[_NT]],
1435
887
  });
1436
888
  let body;
1437
- return new __HttpRequest({
1438
- protocol,
1439
- hostname,
1440
- port,
1441
- method: "GET",
1442
- headers,
1443
- path: resolvedPath,
1444
- query,
1445
- body,
1446
- });
889
+ b.m("GET").h(headers).q(query).b(body);
890
+ return b.build();
1447
891
  };
1448
892
  export const se_ListRestoreTestingPlansCommand = async (input, context) => {
1449
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
893
+ const b = rb(input, context);
1450
894
  const headers = {};
1451
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-testing/plans";
895
+ b.bp("/restore-testing/plans");
1452
896
  const query = map({
1453
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1454
- NextToken: [, input.NextToken],
897
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
898
+ [_NT]: [, input[_NT]],
1455
899
  });
1456
900
  let body;
1457
- return new __HttpRequest({
1458
- protocol,
1459
- hostname,
1460
- port,
1461
- method: "GET",
1462
- headers,
1463
- path: resolvedPath,
1464
- query,
1465
- body,
1466
- });
901
+ b.m("GET").h(headers).q(query).b(body);
902
+ return b.build();
1467
903
  };
1468
904
  export const se_ListRestoreTestingSelectionsCommand = async (input, context) => {
1469
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
905
+ const b = rb(input, context);
1470
906
  const headers = {};
1471
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1472
- "/restore-testing/plans/{RestoreTestingPlanName}/selections";
1473
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
907
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}/selections");
908
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
1474
909
  const query = map({
1475
- MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
1476
- NextToken: [, input.NextToken],
910
+ [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
911
+ [_NT]: [, input[_NT]],
1477
912
  });
1478
913
  let body;
1479
- return new __HttpRequest({
1480
- protocol,
1481
- hostname,
1482
- port,
1483
- method: "GET",
1484
- headers,
1485
- path: resolvedPath,
1486
- query,
1487
- body,
1488
- });
914
+ b.m("GET").h(headers).q(query).b(body);
915
+ return b.build();
1489
916
  };
1490
917
  export const se_ListTagsCommand = async (input, context) => {
1491
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
918
+ const b = rb(input, context);
1492
919
  const headers = {};
1493
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1494
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
920
+ b.bp("/tags/{ResourceArn}");
921
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1495
922
  const query = map({
1496
- nextToken: [, input.NextToken],
1497
- maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
923
+ [_nT]: [, input[_NT]],
924
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1498
925
  });
1499
926
  let body;
1500
- return new __HttpRequest({
1501
- protocol,
1502
- hostname,
1503
- port,
1504
- method: "GET",
1505
- headers,
1506
- path: resolvedPath,
1507
- query,
1508
- body,
1509
- });
927
+ b.m("GET").h(headers).q(query).b(body);
928
+ return b.build();
1510
929
  };
1511
930
  export const se_PutBackupVaultAccessPolicyCommand = async (input, context) => {
1512
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
931
+ const b = rb(input, context);
1513
932
  const headers = {
1514
933
  "content-type": "application/json",
1515
934
  };
1516
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1517
- "/backup-vaults/{BackupVaultName}/access-policy";
1518
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
935
+ b.bp("/backup-vaults/{BackupVaultName}/access-policy");
936
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1519
937
  let body;
1520
938
  body = JSON.stringify(take(input, {
1521
939
  Policy: [],
1522
940
  }));
1523
- return new __HttpRequest({
1524
- protocol,
1525
- hostname,
1526
- port,
1527
- method: "PUT",
1528
- headers,
1529
- path: resolvedPath,
1530
- body,
1531
- });
941
+ b.m("PUT").h(headers).b(body);
942
+ return b.build();
1532
943
  };
1533
944
  export const se_PutBackupVaultLockConfigurationCommand = async (input, context) => {
1534
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
945
+ const b = rb(input, context);
1535
946
  const headers = {
1536
947
  "content-type": "application/json",
1537
948
  };
1538
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1539
- "/backup-vaults/{BackupVaultName}/vault-lock";
1540
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
949
+ b.bp("/backup-vaults/{BackupVaultName}/vault-lock");
950
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1541
951
  let body;
1542
952
  body = JSON.stringify(take(input, {
1543
953
  ChangeableForDays: [],
1544
954
  MaxRetentionDays: [],
1545
955
  MinRetentionDays: [],
1546
956
  }));
1547
- return new __HttpRequest({
1548
- protocol,
1549
- hostname,
1550
- port,
1551
- method: "PUT",
1552
- headers,
1553
- path: resolvedPath,
1554
- body,
1555
- });
957
+ b.m("PUT").h(headers).b(body);
958
+ return b.build();
1556
959
  };
1557
960
  export const se_PutBackupVaultNotificationsCommand = async (input, context) => {
1558
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
961
+ const b = rb(input, context);
1559
962
  const headers = {
1560
963
  "content-type": "application/json",
1561
964
  };
1562
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1563
- "/backup-vaults/{BackupVaultName}/notification-configuration";
1564
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
965
+ b.bp("/backup-vaults/{BackupVaultName}/notification-configuration");
966
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1565
967
  let body;
1566
968
  body = JSON.stringify(take(input, {
1567
969
  BackupVaultEvents: (_) => _json(_),
1568
970
  SNSTopicArn: [],
1569
971
  }));
1570
- return new __HttpRequest({
1571
- protocol,
1572
- hostname,
1573
- port,
1574
- method: "PUT",
1575
- headers,
1576
- path: resolvedPath,
1577
- body,
1578
- });
972
+ b.m("PUT").h(headers).b(body);
973
+ return b.build();
1579
974
  };
1580
975
  export const se_PutRestoreValidationResultCommand = async (input, context) => {
1581
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
976
+ const b = rb(input, context);
1582
977
  const headers = {
1583
978
  "content-type": "application/json",
1584
979
  };
1585
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-jobs/{RestoreJobId}/validations";
1586
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreJobId", () => input.RestoreJobId, "{RestoreJobId}", false);
980
+ b.bp("/restore-jobs/{RestoreJobId}/validations");
981
+ b.p("RestoreJobId", () => input.RestoreJobId, "{RestoreJobId}", false);
1587
982
  let body;
1588
983
  body = JSON.stringify(take(input, {
1589
984
  ValidationStatus: [],
1590
985
  ValidationStatusMessage: [],
1591
986
  }));
1592
- return new __HttpRequest({
1593
- protocol,
1594
- hostname,
1595
- port,
1596
- method: "PUT",
1597
- headers,
1598
- path: resolvedPath,
1599
- body,
1600
- });
987
+ b.m("PUT").h(headers).b(body);
988
+ return b.build();
1601
989
  };
1602
990
  export const se_StartBackupJobCommand = async (input, context) => {
1603
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
991
+ const b = rb(input, context);
1604
992
  const headers = {
1605
993
  "content-type": "application/json",
1606
994
  };
1607
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-jobs";
995
+ b.bp("/backup-jobs");
1608
996
  let body;
1609
997
  body = JSON.stringify(take(input, {
1610
998
  BackupOptions: (_) => _json(_),
@@ -1617,22 +1005,15 @@ export const se_StartBackupJobCommand = async (input, context) => {
1617
1005
  ResourceArn: [],
1618
1006
  StartWindowMinutes: [],
1619
1007
  }));
1620
- return new __HttpRequest({
1621
- protocol,
1622
- hostname,
1623
- port,
1624
- method: "PUT",
1625
- headers,
1626
- path: resolvedPath,
1627
- body,
1628
- });
1008
+ b.m("PUT").h(headers).b(body);
1009
+ return b.build();
1629
1010
  };
1630
1011
  export const se_StartCopyJobCommand = async (input, context) => {
1631
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1012
+ const b = rb(input, context);
1632
1013
  const headers = {
1633
1014
  "content-type": "application/json",
1634
1015
  };
1635
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/copy-jobs";
1016
+ b.bp("/copy-jobs");
1636
1017
  let body;
1637
1018
  body = JSON.stringify(take(input, {
1638
1019
  DestinationBackupVaultArn: [],
@@ -1642,43 +1023,29 @@ export const se_StartCopyJobCommand = async (input, context) => {
1642
1023
  RecoveryPointArn: [],
1643
1024
  SourceBackupVaultName: [],
1644
1025
  }));
1645
- return new __HttpRequest({
1646
- protocol,
1647
- hostname,
1648
- port,
1649
- method: "PUT",
1650
- headers,
1651
- path: resolvedPath,
1652
- body,
1653
- });
1026
+ b.m("PUT").h(headers).b(body);
1027
+ return b.build();
1654
1028
  };
1655
1029
  export const se_StartReportJobCommand = async (input, context) => {
1656
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1030
+ const b = rb(input, context);
1657
1031
  const headers = {
1658
1032
  "content-type": "application/json",
1659
1033
  };
1660
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-jobs/{ReportPlanName}";
1661
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
1034
+ b.bp("/audit/report-jobs/{ReportPlanName}");
1035
+ b.p("ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
1662
1036
  let body;
1663
1037
  body = JSON.stringify(take(input, {
1664
1038
  IdempotencyToken: [true, (_) => _ ?? generateIdempotencyToken()],
1665
1039
  }));
1666
- return new __HttpRequest({
1667
- protocol,
1668
- hostname,
1669
- port,
1670
- method: "POST",
1671
- headers,
1672
- path: resolvedPath,
1673
- body,
1674
- });
1040
+ b.m("POST").h(headers).b(body);
1041
+ return b.build();
1675
1042
  };
1676
1043
  export const se_StartRestoreJobCommand = async (input, context) => {
1677
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1044
+ const b = rb(input, context);
1678
1045
  const headers = {
1679
1046
  "content-type": "application/json",
1680
1047
  };
1681
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/restore-jobs";
1048
+ b.bp("/restore-jobs");
1682
1049
  let body;
1683
1050
  body = JSON.stringify(take(input, {
1684
1051
  CopySourceTagsToRestoredResource: [],
@@ -1688,189 +1055,125 @@ export const se_StartRestoreJobCommand = async (input, context) => {
1688
1055
  RecoveryPointArn: [],
1689
1056
  ResourceType: [],
1690
1057
  }));
1691
- return new __HttpRequest({
1692
- protocol,
1693
- hostname,
1694
- port,
1695
- method: "PUT",
1696
- headers,
1697
- path: resolvedPath,
1698
- body,
1699
- });
1058
+ b.m("PUT").h(headers).b(body);
1059
+ return b.build();
1700
1060
  };
1701
1061
  export const se_StopBackupJobCommand = async (input, context) => {
1702
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1062
+ const b = rb(input, context);
1703
1063
  const headers = {};
1704
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup-jobs/{BackupJobId}";
1705
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupJobId", () => input.BackupJobId, "{BackupJobId}", false);
1064
+ b.bp("/backup-jobs/{BackupJobId}");
1065
+ b.p("BackupJobId", () => input.BackupJobId, "{BackupJobId}", false);
1706
1066
  let body;
1707
- return new __HttpRequest({
1708
- protocol,
1709
- hostname,
1710
- port,
1711
- method: "POST",
1712
- headers,
1713
- path: resolvedPath,
1714
- body,
1715
- });
1067
+ b.m("POST").h(headers).b(body);
1068
+ return b.build();
1716
1069
  };
1717
1070
  export const se_TagResourceCommand = async (input, context) => {
1718
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1071
+ const b = rb(input, context);
1719
1072
  const headers = {
1720
1073
  "content-type": "application/json",
1721
1074
  };
1722
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
1723
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1075
+ b.bp("/tags/{ResourceArn}");
1076
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1724
1077
  let body;
1725
1078
  body = JSON.stringify(take(input, {
1726
1079
  Tags: (_) => _json(_),
1727
1080
  }));
1728
- return new __HttpRequest({
1729
- protocol,
1730
- hostname,
1731
- port,
1732
- method: "POST",
1733
- headers,
1734
- path: resolvedPath,
1735
- body,
1736
- });
1081
+ b.m("POST").h(headers).b(body);
1082
+ return b.build();
1737
1083
  };
1738
1084
  export const se_UntagResourceCommand = async (input, context) => {
1739
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1085
+ const b = rb(input, context);
1740
1086
  const headers = {
1741
1087
  "content-type": "application/json",
1742
1088
  };
1743
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/untag/{ResourceArn}";
1744
- resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1089
+ b.bp("/untag/{ResourceArn}");
1090
+ b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
1745
1091
  let body;
1746
1092
  body = JSON.stringify(take(input, {
1747
1093
  TagKeyList: (_) => _json(_),
1748
1094
  }));
1749
- return new __HttpRequest({
1750
- protocol,
1751
- hostname,
1752
- port,
1753
- method: "POST",
1754
- headers,
1755
- path: resolvedPath,
1756
- body,
1757
- });
1095
+ b.m("POST").h(headers).b(body);
1096
+ return b.build();
1758
1097
  };
1759
1098
  export const se_UpdateBackupPlanCommand = async (input, context) => {
1760
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1099
+ const b = rb(input, context);
1761
1100
  const headers = {
1762
1101
  "content-type": "application/json",
1763
1102
  };
1764
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/backup/plans/{BackupPlanId}";
1765
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
1103
+ b.bp("/backup/plans/{BackupPlanId}");
1104
+ b.p("BackupPlanId", () => input.BackupPlanId, "{BackupPlanId}", false);
1766
1105
  let body;
1767
1106
  body = JSON.stringify(take(input, {
1768
1107
  BackupPlan: (_) => _json(_),
1769
1108
  }));
1770
- return new __HttpRequest({
1771
- protocol,
1772
- hostname,
1773
- port,
1774
- method: "POST",
1775
- headers,
1776
- path: resolvedPath,
1777
- body,
1778
- });
1109
+ b.m("POST").h(headers).b(body);
1110
+ return b.build();
1779
1111
  };
1780
1112
  export const se_UpdateFrameworkCommand = async (input, context) => {
1781
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1113
+ const b = rb(input, context);
1782
1114
  const headers = {
1783
1115
  "content-type": "application/json",
1784
1116
  };
1785
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/frameworks/{FrameworkName}";
1786
- resolvedPath = __resolvedPath(resolvedPath, input, "FrameworkName", () => input.FrameworkName, "{FrameworkName}", false);
1117
+ b.bp("/audit/frameworks/{FrameworkName}");
1118
+ b.p("FrameworkName", () => input.FrameworkName, "{FrameworkName}", false);
1787
1119
  let body;
1788
1120
  body = JSON.stringify(take(input, {
1789
1121
  FrameworkControls: (_) => _json(_),
1790
1122
  FrameworkDescription: [],
1791
1123
  IdempotencyToken: [true, (_) => _ ?? generateIdempotencyToken()],
1792
1124
  }));
1793
- return new __HttpRequest({
1794
- protocol,
1795
- hostname,
1796
- port,
1797
- method: "PUT",
1798
- headers,
1799
- path: resolvedPath,
1800
- body,
1801
- });
1125
+ b.m("PUT").h(headers).b(body);
1126
+ return b.build();
1802
1127
  };
1803
1128
  export const se_UpdateGlobalSettingsCommand = async (input, context) => {
1804
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1129
+ const b = rb(input, context);
1805
1130
  const headers = {
1806
1131
  "content-type": "application/json",
1807
1132
  };
1808
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/global-settings";
1133
+ b.bp("/global-settings");
1809
1134
  let body;
1810
1135
  body = JSON.stringify(take(input, {
1811
1136
  GlobalSettings: (_) => _json(_),
1812
1137
  }));
1813
- return new __HttpRequest({
1814
- protocol,
1815
- hostname,
1816
- port,
1817
- method: "PUT",
1818
- headers,
1819
- path: resolvedPath,
1820
- body,
1821
- });
1138
+ b.m("PUT").h(headers).b(body);
1139
+ return b.build();
1822
1140
  };
1823
1141
  export const se_UpdateRecoveryPointLifecycleCommand = async (input, context) => {
1824
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1142
+ const b = rb(input, context);
1825
1143
  const headers = {
1826
1144
  "content-type": "application/json",
1827
1145
  };
1828
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1829
- "/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}";
1830
- resolvedPath = __resolvedPath(resolvedPath, input, "BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1831
- resolvedPath = __resolvedPath(resolvedPath, input, "RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
1146
+ b.bp("/backup-vaults/{BackupVaultName}/recovery-points/{RecoveryPointArn}");
1147
+ b.p("BackupVaultName", () => input.BackupVaultName, "{BackupVaultName}", false);
1148
+ b.p("RecoveryPointArn", () => input.RecoveryPointArn, "{RecoveryPointArn}", false);
1832
1149
  let body;
1833
1150
  body = JSON.stringify(take(input, {
1834
1151
  Lifecycle: (_) => _json(_),
1835
1152
  }));
1836
- return new __HttpRequest({
1837
- protocol,
1838
- hostname,
1839
- port,
1840
- method: "POST",
1841
- headers,
1842
- path: resolvedPath,
1843
- body,
1844
- });
1153
+ b.m("POST").h(headers).b(body);
1154
+ return b.build();
1845
1155
  };
1846
1156
  export const se_UpdateRegionSettingsCommand = async (input, context) => {
1847
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1157
+ const b = rb(input, context);
1848
1158
  const headers = {
1849
1159
  "content-type": "application/json",
1850
1160
  };
1851
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/account-settings";
1161
+ b.bp("/account-settings");
1852
1162
  let body;
1853
1163
  body = JSON.stringify(take(input, {
1854
1164
  ResourceTypeManagementPreference: (_) => _json(_),
1855
1165
  ResourceTypeOptInPreference: (_) => _json(_),
1856
1166
  }));
1857
- return new __HttpRequest({
1858
- protocol,
1859
- hostname,
1860
- port,
1861
- method: "PUT",
1862
- headers,
1863
- path: resolvedPath,
1864
- body,
1865
- });
1167
+ b.m("PUT").h(headers).b(body);
1168
+ return b.build();
1866
1169
  };
1867
1170
  export const se_UpdateReportPlanCommand = async (input, context) => {
1868
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1171
+ const b = rb(input, context);
1869
1172
  const headers = {
1870
1173
  "content-type": "application/json",
1871
1174
  };
1872
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/audit/report-plans/{ReportPlanName}";
1873
- resolvedPath = __resolvedPath(resolvedPath, input, "ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
1175
+ b.bp("/audit/report-plans/{ReportPlanName}");
1176
+ b.p("ReportPlanName", () => input.ReportPlanName, "{ReportPlanName}", false);
1874
1177
  let body;
1875
1178
  body = JSON.stringify(take(input, {
1876
1179
  IdempotencyToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1878,60 +1181,37 @@ export const se_UpdateReportPlanCommand = async (input, context) => {
1878
1181
  ReportPlanDescription: [],
1879
1182
  ReportSetting: (_) => _json(_),
1880
1183
  }));
1881
- return new __HttpRequest({
1882
- protocol,
1883
- hostname,
1884
- port,
1885
- method: "PUT",
1886
- headers,
1887
- path: resolvedPath,
1888
- body,
1889
- });
1184
+ b.m("PUT").h(headers).b(body);
1185
+ return b.build();
1890
1186
  };
1891
1187
  export const se_UpdateRestoreTestingPlanCommand = async (input, context) => {
1892
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1188
+ const b = rb(input, context);
1893
1189
  const headers = {
1894
1190
  "content-type": "application/json",
1895
1191
  };
1896
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1897
- "/restore-testing/plans/{RestoreTestingPlanName}";
1898
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
1192
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}");
1193
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
1899
1194
  let body;
1900
1195
  body = JSON.stringify(take(input, {
1901
1196
  RestoreTestingPlan: (_) => _json(_),
1902
1197
  }));
1903
- return new __HttpRequest({
1904
- protocol,
1905
- hostname,
1906
- port,
1907
- method: "PUT",
1908
- headers,
1909
- path: resolvedPath,
1910
- body,
1911
- });
1198
+ b.m("PUT").h(headers).b(body);
1199
+ return b.build();
1912
1200
  };
1913
1201
  export const se_UpdateRestoreTestingSelectionCommand = async (input, context) => {
1914
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1202
+ const b = rb(input, context);
1915
1203
  const headers = {
1916
1204
  "content-type": "application/json",
1917
1205
  };
1918
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1919
- "/restore-testing/plans/{RestoreTestingPlanName}/selections/{RestoreTestingSelectionName}";
1920
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
1921
- resolvedPath = __resolvedPath(resolvedPath, input, "RestoreTestingSelectionName", () => input.RestoreTestingSelectionName, "{RestoreTestingSelectionName}", false);
1206
+ b.bp("/restore-testing/plans/{RestoreTestingPlanName}/selections/{RestoreTestingSelectionName}");
1207
+ b.p("RestoreTestingPlanName", () => input.RestoreTestingPlanName, "{RestoreTestingPlanName}", false);
1208
+ b.p("RestoreTestingSelectionName", () => input.RestoreTestingSelectionName, "{RestoreTestingSelectionName}", false);
1922
1209
  let body;
1923
1210
  body = JSON.stringify(take(input, {
1924
1211
  RestoreTestingSelection: (_) => _json(_),
1925
1212
  }));
1926
- return new __HttpRequest({
1927
- protocol,
1928
- hostname,
1929
- port,
1930
- method: "PUT",
1931
- headers,
1932
- path: resolvedPath,
1933
- body,
1934
- });
1213
+ b.m("PUT").h(headers).b(body);
1214
+ return b.build();
1935
1215
  };
1936
1216
  export const de_CancelLegalHoldCommand = async (output, context) => {
1937
1217
  if (output.statusCode !== 201 && output.statusCode >= 300) {
@@ -6522,6 +5802,74 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
6522
5802
  value !== "" &&
6523
5803
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
6524
5804
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
5805
+ const _AI = "AccountId";
5806
+ const _AP = "AggregationPeriod";
5807
+ const _BAI = "ByAccountId";
5808
+ const _BBPI = "ByBackupPlanId";
5809
+ const _BBVN = "ByBackupVaultName";
5810
+ const _BCA = "ByCreatedAfter";
5811
+ const _BCAy = "ByCompleteAfter";
5812
+ const _BCAyr = "ByCreationAfter";
5813
+ const _BCB = "ByCreatedBefore";
5814
+ const _BCBy = "ByCompleteBefore";
5815
+ const _BCByr = "ByCreationBefore";
5816
+ const _BDVA = "ByDestinationVaultArn";
5817
+ const _BMC = "ByMessageCategory";
5818
+ const _BPJI = "ByParentJobId";
5819
+ const _BPRPA = "ByParentRecoveryPointArn";
5820
+ const _BRA = "ByResourceArn";
5821
+ const _BRPCDA = "ByRecoveryPointCreationDateAfter";
5822
+ const _BRPCDB = "ByRecoveryPointCreationDateBefore";
5823
+ const _BRPN = "ByReportPlanName";
5824
+ const _BRT = "ByResourceType";
5825
+ const _BRTPA = "ByRestoreTestingPlanArn";
5826
+ const _BS = "ByState";
5827
+ const _BSy = "ByShared";
5828
+ const _BSyt = "ByStatus";
5829
+ const _BVAI = "BackupVaultAccountId";
5830
+ const _BVN = "BackupVaultName";
5831
+ const _BVT = "ByVaultType";
5832
+ const _CA = "CreationAfter";
5833
+ const _CB = "CreationBefore";
5834
+ const _CD = "CancelDescription";
5835
+ const _ID = "IncludeDeleted";
5836
+ const _MC = "MessageCategory";
5837
+ const _MR = "MaxResults";
5838
+ const _NT = "NextToken";
5839
+ const _RPA = "RecoveryPointArn";
5840
+ const _RPN = "ReportPlanName";
5841
+ const _RRID = "RetainRecordInDays";
5842
+ const _RT = "ResourceType";
5843
+ const _S = "State";
5844
+ const _St = "Status";
5845
+ const _VI = "VersionId";
5846
+ const _aI = "accountId";
5847
+ const _bPI = "backupPlanId";
5848
+ const _bVAI = "backupVaultAccountId";
5849
+ const _bVN = "backupVaultName";
5850
+ const _cA = "createdAfter";
5851
+ const _cAo = "completeAfter";
5852
+ const _cB = "createdBefore";
5853
+ const _cBo = "completeBefore";
5854
+ const _cD = "cancelDescription";
5855
+ const _dVA = "destinationVaultArn";
5856
+ const _iD = "includeDeleted";
5857
+ const _mC = "messageCategory";
5858
+ const _mR = "maxResults";
5859
+ const _nT = "nextToken";
5860
+ const _pJI = "parentJobId";
5861
+ const _pRPA = "parentRecoveryPointArn";
5862
+ const _rA = "resourceArn";
5863
+ const _rPCDA = "recoveryPointCreationDateAfter";
5864
+ const _rPCDB = "recoveryPointCreationDateBefore";
5865
+ const _rRID = "retainRecordInDays";
5866
+ const _rT = "resourceType";
5867
+ const _rTPA = "restoreTestingPlanArn";
5868
+ const _s = "state";
5869
+ const _sh = "shared";
5870
+ const _st = "status";
5871
+ const _vI = "versionId";
5872
+ const _vT = "vaultType";
6525
5873
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
6526
5874
  if (encoded.length) {
6527
5875
  return JSON.parse(encoded);