@aws-sdk/client-mgn 3.503.1 → 3.507.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.
package/dist-cjs/index.js CHANGED
@@ -2088,7 +2088,7 @@ var se_UpdateWaveCommand = /* @__PURE__ */ __name(async (input, context) => {
2088
2088
  }, "se_UpdateWaveCommand");
2089
2089
  var de_ArchiveApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
2090
2090
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2091
- return de_ArchiveApplicationCommandError(output, context);
2091
+ return de_CommandError(output, context);
2092
2092
  }
2093
2093
  const contents = (0, import_smithy_client.map)({
2094
2094
  $metadata: deserializeMetadata(output)
@@ -2109,37 +2109,9 @@ var de_ArchiveApplicationCommand = /* @__PURE__ */ __name(async (output, context
2109
2109
  Object.assign(contents, doc);
2110
2110
  return contents;
2111
2111
  }, "de_ArchiveApplicationCommand");
2112
- var de_ArchiveApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
2113
- const parsedOutput = {
2114
- ...output,
2115
- body: await parseErrorBody(output.body, context)
2116
- };
2117
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2118
- switch (errorCode) {
2119
- case "ConflictException":
2120
- case "com.amazonaws.mgn#ConflictException":
2121
- throw await de_ConflictExceptionRes(parsedOutput, context);
2122
- case "ResourceNotFoundException":
2123
- case "com.amazonaws.mgn#ResourceNotFoundException":
2124
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2125
- case "ServiceQuotaExceededException":
2126
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
2127
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2128
- case "UninitializedAccountException":
2129
- case "com.amazonaws.mgn#UninitializedAccountException":
2130
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2131
- default:
2132
- const parsedBody = parsedOutput.body;
2133
- return throwDefaultError({
2134
- output,
2135
- parsedBody,
2136
- errorCode
2137
- });
2138
- }
2139
- }, "de_ArchiveApplicationCommandError");
2140
2112
  var de_ArchiveWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
2141
2113
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2142
- return de_ArchiveWaveCommandError(output, context);
2114
+ return de_CommandError(output, context);
2143
2115
  }
2144
2116
  const contents = (0, import_smithy_client.map)({
2145
2117
  $metadata: deserializeMetadata(output)
@@ -2159,37 +2131,9 @@ var de_ArchiveWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
2159
2131
  Object.assign(contents, doc);
2160
2132
  return contents;
2161
2133
  }, "de_ArchiveWaveCommand");
2162
- var de_ArchiveWaveCommandError = /* @__PURE__ */ __name(async (output, context) => {
2163
- const parsedOutput = {
2164
- ...output,
2165
- body: await parseErrorBody(output.body, context)
2166
- };
2167
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2168
- switch (errorCode) {
2169
- case "ConflictException":
2170
- case "com.amazonaws.mgn#ConflictException":
2171
- throw await de_ConflictExceptionRes(parsedOutput, context);
2172
- case "ResourceNotFoundException":
2173
- case "com.amazonaws.mgn#ResourceNotFoundException":
2174
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2175
- case "ServiceQuotaExceededException":
2176
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
2177
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2178
- case "UninitializedAccountException":
2179
- case "com.amazonaws.mgn#UninitializedAccountException":
2180
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2181
- default:
2182
- const parsedBody = parsedOutput.body;
2183
- return throwDefaultError({
2184
- output,
2185
- parsedBody,
2186
- errorCode
2187
- });
2188
- }
2189
- }, "de_ArchiveWaveCommandError");
2190
2134
  var de_AssociateApplicationsCommand = /* @__PURE__ */ __name(async (output, context) => {
2191
2135
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2192
- return de_AssociateApplicationsCommandError(output, context);
2136
+ return de_CommandError(output, context);
2193
2137
  }
2194
2138
  const contents = (0, import_smithy_client.map)({
2195
2139
  $metadata: deserializeMetadata(output)
@@ -2197,37 +2141,9 @@ var de_AssociateApplicationsCommand = /* @__PURE__ */ __name(async (output, cont
2197
2141
  await (0, import_smithy_client.collectBody)(output.body, context);
2198
2142
  return contents;
2199
2143
  }, "de_AssociateApplicationsCommand");
2200
- var de_AssociateApplicationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2201
- const parsedOutput = {
2202
- ...output,
2203
- body: await parseErrorBody(output.body, context)
2204
- };
2205
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2206
- switch (errorCode) {
2207
- case "ConflictException":
2208
- case "com.amazonaws.mgn#ConflictException":
2209
- throw await de_ConflictExceptionRes(parsedOutput, context);
2210
- case "ResourceNotFoundException":
2211
- case "com.amazonaws.mgn#ResourceNotFoundException":
2212
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2213
- case "ServiceQuotaExceededException":
2214
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
2215
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2216
- case "UninitializedAccountException":
2217
- case "com.amazonaws.mgn#UninitializedAccountException":
2218
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2219
- default:
2220
- const parsedBody = parsedOutput.body;
2221
- return throwDefaultError({
2222
- output,
2223
- parsedBody,
2224
- errorCode
2225
- });
2226
- }
2227
- }, "de_AssociateApplicationsCommandError");
2228
2144
  var de_AssociateSourceServersCommand = /* @__PURE__ */ __name(async (output, context) => {
2229
2145
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2230
- return de_AssociateSourceServersCommandError(output, context);
2146
+ return de_CommandError(output, context);
2231
2147
  }
2232
2148
  const contents = (0, import_smithy_client.map)({
2233
2149
  $metadata: deserializeMetadata(output)
@@ -2235,37 +2151,9 @@ var de_AssociateSourceServersCommand = /* @__PURE__ */ __name(async (output, con
2235
2151
  await (0, import_smithy_client.collectBody)(output.body, context);
2236
2152
  return contents;
2237
2153
  }, "de_AssociateSourceServersCommand");
2238
- var de_AssociateSourceServersCommandError = /* @__PURE__ */ __name(async (output, context) => {
2239
- const parsedOutput = {
2240
- ...output,
2241
- body: await parseErrorBody(output.body, context)
2242
- };
2243
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2244
- switch (errorCode) {
2245
- case "ConflictException":
2246
- case "com.amazonaws.mgn#ConflictException":
2247
- throw await de_ConflictExceptionRes(parsedOutput, context);
2248
- case "ResourceNotFoundException":
2249
- case "com.amazonaws.mgn#ResourceNotFoundException":
2250
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2251
- case "ServiceQuotaExceededException":
2252
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
2253
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2254
- case "UninitializedAccountException":
2255
- case "com.amazonaws.mgn#UninitializedAccountException":
2256
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2257
- default:
2258
- const parsedBody = parsedOutput.body;
2259
- return throwDefaultError({
2260
- output,
2261
- parsedBody,
2262
- errorCode
2263
- });
2264
- }
2265
- }, "de_AssociateSourceServersCommandError");
2266
2154
  var de_ChangeServerLifeCycleStateCommand = /* @__PURE__ */ __name(async (output, context) => {
2267
2155
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2268
- return de_ChangeServerLifeCycleStateCommandError(output, context);
2156
+ return de_CommandError(output, context);
2269
2157
  }
2270
2158
  const contents = (0, import_smithy_client.map)({
2271
2159
  $metadata: deserializeMetadata(output)
@@ -2290,37 +2178,9 @@ var de_ChangeServerLifeCycleStateCommand = /* @__PURE__ */ __name(async (output,
2290
2178
  Object.assign(contents, doc);
2291
2179
  return contents;
2292
2180
  }, "de_ChangeServerLifeCycleStateCommand");
2293
- var de_ChangeServerLifeCycleStateCommandError = /* @__PURE__ */ __name(async (output, context) => {
2294
- const parsedOutput = {
2295
- ...output,
2296
- body: await parseErrorBody(output.body, context)
2297
- };
2298
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2299
- switch (errorCode) {
2300
- case "ConflictException":
2301
- case "com.amazonaws.mgn#ConflictException":
2302
- throw await de_ConflictExceptionRes(parsedOutput, context);
2303
- case "ResourceNotFoundException":
2304
- case "com.amazonaws.mgn#ResourceNotFoundException":
2305
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2306
- case "UninitializedAccountException":
2307
- case "com.amazonaws.mgn#UninitializedAccountException":
2308
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2309
- case "ValidationException":
2310
- case "com.amazonaws.mgn#ValidationException":
2311
- throw await de_ValidationExceptionRes(parsedOutput, context);
2312
- default:
2313
- const parsedBody = parsedOutput.body;
2314
- return throwDefaultError({
2315
- output,
2316
- parsedBody,
2317
- errorCode
2318
- });
2319
- }
2320
- }, "de_ChangeServerLifeCycleStateCommandError");
2321
2181
  var de_CreateApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
2322
2182
  if (output.statusCode !== 201 && output.statusCode >= 300) {
2323
- return de_CreateApplicationCommandError(output, context);
2183
+ return de_CommandError(output, context);
2324
2184
  }
2325
2185
  const contents = (0, import_smithy_client.map)({
2326
2186
  $metadata: deserializeMetadata(output)
@@ -2341,34 +2201,9 @@ var de_CreateApplicationCommand = /* @__PURE__ */ __name(async (output, context)
2341
2201
  Object.assign(contents, doc);
2342
2202
  return contents;
2343
2203
  }, "de_CreateApplicationCommand");
2344
- var de_CreateApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
2345
- const parsedOutput = {
2346
- ...output,
2347
- body: await parseErrorBody(output.body, context)
2348
- };
2349
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2350
- switch (errorCode) {
2351
- case "ConflictException":
2352
- case "com.amazonaws.mgn#ConflictException":
2353
- throw await de_ConflictExceptionRes(parsedOutput, context);
2354
- case "ServiceQuotaExceededException":
2355
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
2356
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2357
- case "UninitializedAccountException":
2358
- case "com.amazonaws.mgn#UninitializedAccountException":
2359
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2360
- default:
2361
- const parsedBody = parsedOutput.body;
2362
- return throwDefaultError({
2363
- output,
2364
- parsedBody,
2365
- errorCode
2366
- });
2367
- }
2368
- }, "de_CreateApplicationCommandError");
2369
2204
  var de_CreateConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
2370
2205
  if (output.statusCode !== 201 && output.statusCode >= 300) {
2371
- return de_CreateConnectorCommandError(output, context);
2206
+ return de_CommandError(output, context);
2372
2207
  }
2373
2208
  const contents = (0, import_smithy_client.map)({
2374
2209
  $metadata: deserializeMetadata(output)
@@ -2385,31 +2220,9 @@ var de_CreateConnectorCommand = /* @__PURE__ */ __name(async (output, context) =
2385
2220
  Object.assign(contents, doc);
2386
2221
  return contents;
2387
2222
  }, "de_CreateConnectorCommand");
2388
- var de_CreateConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
2389
- const parsedOutput = {
2390
- ...output,
2391
- body: await parseErrorBody(output.body, context)
2392
- };
2393
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2394
- switch (errorCode) {
2395
- case "UninitializedAccountException":
2396
- case "com.amazonaws.mgn#UninitializedAccountException":
2397
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2398
- case "ValidationException":
2399
- case "com.amazonaws.mgn#ValidationException":
2400
- throw await de_ValidationExceptionRes(parsedOutput, context);
2401
- default:
2402
- const parsedBody = parsedOutput.body;
2403
- return throwDefaultError({
2404
- output,
2405
- parsedBody,
2406
- errorCode
2407
- });
2408
- }
2409
- }, "de_CreateConnectorCommandError");
2410
2223
  var de_CreateLaunchConfigurationTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
2411
2224
  if (output.statusCode !== 201 && output.statusCode >= 300) {
2412
- return de_CreateLaunchConfigurationTemplateCommandError(output, context);
2225
+ return de_CommandError(output, context);
2413
2226
  }
2414
2227
  const contents = (0, import_smithy_client.map)({
2415
2228
  $metadata: deserializeMetadata(output)
@@ -2437,34 +2250,9 @@ var de_CreateLaunchConfigurationTemplateCommand = /* @__PURE__ */ __name(async (
2437
2250
  Object.assign(contents, doc);
2438
2251
  return contents;
2439
2252
  }, "de_CreateLaunchConfigurationTemplateCommand");
2440
- var de_CreateLaunchConfigurationTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
2441
- const parsedOutput = {
2442
- ...output,
2443
- body: await parseErrorBody(output.body, context)
2444
- };
2445
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2446
- switch (errorCode) {
2447
- case "AccessDeniedException":
2448
- case "com.amazonaws.mgn#AccessDeniedException":
2449
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2450
- case "UninitializedAccountException":
2451
- case "com.amazonaws.mgn#UninitializedAccountException":
2452
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2453
- case "ValidationException":
2454
- case "com.amazonaws.mgn#ValidationException":
2455
- throw await de_ValidationExceptionRes(parsedOutput, context);
2456
- default:
2457
- const parsedBody = parsedOutput.body;
2458
- return throwDefaultError({
2459
- output,
2460
- parsedBody,
2461
- errorCode
2462
- });
2463
- }
2464
- }, "de_CreateLaunchConfigurationTemplateCommandError");
2465
2253
  var de_CreateReplicationConfigurationTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
2466
2254
  if (output.statusCode !== 201 && output.statusCode >= 300) {
2467
- return de_CreateReplicationConfigurationTemplateCommandError(output, context);
2255
+ return de_CommandError(output, context);
2468
2256
  }
2469
2257
  const contents = (0, import_smithy_client.map)({
2470
2258
  $metadata: deserializeMetadata(output)
@@ -2491,34 +2279,9 @@ var de_CreateReplicationConfigurationTemplateCommand = /* @__PURE__ */ __name(as
2491
2279
  Object.assign(contents, doc);
2492
2280
  return contents;
2493
2281
  }, "de_CreateReplicationConfigurationTemplateCommand");
2494
- var de_CreateReplicationConfigurationTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
2495
- const parsedOutput = {
2496
- ...output,
2497
- body: await parseErrorBody(output.body, context)
2498
- };
2499
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2500
- switch (errorCode) {
2501
- case "AccessDeniedException":
2502
- case "com.amazonaws.mgn#AccessDeniedException":
2503
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2504
- case "UninitializedAccountException":
2505
- case "com.amazonaws.mgn#UninitializedAccountException":
2506
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2507
- case "ValidationException":
2508
- case "com.amazonaws.mgn#ValidationException":
2509
- throw await de_ValidationExceptionRes(parsedOutput, context);
2510
- default:
2511
- const parsedBody = parsedOutput.body;
2512
- return throwDefaultError({
2513
- output,
2514
- parsedBody,
2515
- errorCode
2516
- });
2517
- }
2518
- }, "de_CreateReplicationConfigurationTemplateCommandError");
2519
2282
  var de_CreateWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
2520
2283
  if (output.statusCode !== 201 && output.statusCode >= 300) {
2521
- return de_CreateWaveCommandError(output, context);
2284
+ return de_CommandError(output, context);
2522
2285
  }
2523
2286
  const contents = (0, import_smithy_client.map)({
2524
2287
  $metadata: deserializeMetadata(output)
@@ -2538,34 +2301,9 @@ var de_CreateWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
2538
2301
  Object.assign(contents, doc);
2539
2302
  return contents;
2540
2303
  }, "de_CreateWaveCommand");
2541
- var de_CreateWaveCommandError = /* @__PURE__ */ __name(async (output, context) => {
2542
- const parsedOutput = {
2543
- ...output,
2544
- body: await parseErrorBody(output.body, context)
2545
- };
2546
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2547
- switch (errorCode) {
2548
- case "ConflictException":
2549
- case "com.amazonaws.mgn#ConflictException":
2550
- throw await de_ConflictExceptionRes(parsedOutput, context);
2551
- case "ServiceQuotaExceededException":
2552
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
2553
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
2554
- case "UninitializedAccountException":
2555
- case "com.amazonaws.mgn#UninitializedAccountException":
2556
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2557
- default:
2558
- const parsedBody = parsedOutput.body;
2559
- return throwDefaultError({
2560
- output,
2561
- parsedBody,
2562
- errorCode
2563
- });
2564
- }
2565
- }, "de_CreateWaveCommandError");
2566
2304
  var de_DeleteApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
2567
2305
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2568
- return de_DeleteApplicationCommandError(output, context);
2306
+ return de_CommandError(output, context);
2569
2307
  }
2570
2308
  const contents = (0, import_smithy_client.map)({
2571
2309
  $metadata: deserializeMetadata(output)
@@ -2573,34 +2311,9 @@ var de_DeleteApplicationCommand = /* @__PURE__ */ __name(async (output, context)
2573
2311
  await (0, import_smithy_client.collectBody)(output.body, context);
2574
2312
  return contents;
2575
2313
  }, "de_DeleteApplicationCommand");
2576
- var de_DeleteApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
2577
- const parsedOutput = {
2578
- ...output,
2579
- body: await parseErrorBody(output.body, context)
2580
- };
2581
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2582
- switch (errorCode) {
2583
- case "ConflictException":
2584
- case "com.amazonaws.mgn#ConflictException":
2585
- throw await de_ConflictExceptionRes(parsedOutput, context);
2586
- case "ResourceNotFoundException":
2587
- case "com.amazonaws.mgn#ResourceNotFoundException":
2588
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2589
- case "UninitializedAccountException":
2590
- case "com.amazonaws.mgn#UninitializedAccountException":
2591
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2592
- default:
2593
- const parsedBody = parsedOutput.body;
2594
- return throwDefaultError({
2595
- output,
2596
- parsedBody,
2597
- errorCode
2598
- });
2599
- }
2600
- }, "de_DeleteApplicationCommandError");
2601
2314
  var de_DeleteConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
2602
2315
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2603
- return de_DeleteConnectorCommandError(output, context);
2316
+ return de_CommandError(output, context);
2604
2317
  }
2605
2318
  const contents = (0, import_smithy_client.map)({
2606
2319
  $metadata: deserializeMetadata(output)
@@ -2608,34 +2321,9 @@ var de_DeleteConnectorCommand = /* @__PURE__ */ __name(async (output, context) =
2608
2321
  await (0, import_smithy_client.collectBody)(output.body, context);
2609
2322
  return contents;
2610
2323
  }, "de_DeleteConnectorCommand");
2611
- var de_DeleteConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
2612
- const parsedOutput = {
2613
- ...output,
2614
- body: await parseErrorBody(output.body, context)
2615
- };
2616
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2617
- switch (errorCode) {
2618
- case "ResourceNotFoundException":
2619
- case "com.amazonaws.mgn#ResourceNotFoundException":
2620
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2621
- case "UninitializedAccountException":
2622
- case "com.amazonaws.mgn#UninitializedAccountException":
2623
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2624
- case "ValidationException":
2625
- case "com.amazonaws.mgn#ValidationException":
2626
- throw await de_ValidationExceptionRes(parsedOutput, context);
2627
- default:
2628
- const parsedBody = parsedOutput.body;
2629
- return throwDefaultError({
2630
- output,
2631
- parsedBody,
2632
- errorCode
2633
- });
2634
- }
2635
- }, "de_DeleteConnectorCommandError");
2636
2324
  var de_DeleteJobCommand = /* @__PURE__ */ __name(async (output, context) => {
2637
2325
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2638
- return de_DeleteJobCommandError(output, context);
2326
+ return de_CommandError(output, context);
2639
2327
  }
2640
2328
  const contents = (0, import_smithy_client.map)({
2641
2329
  $metadata: deserializeMetadata(output)
@@ -2643,34 +2331,9 @@ var de_DeleteJobCommand = /* @__PURE__ */ __name(async (output, context) => {
2643
2331
  await (0, import_smithy_client.collectBody)(output.body, context);
2644
2332
  return contents;
2645
2333
  }, "de_DeleteJobCommand");
2646
- var de_DeleteJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
2647
- const parsedOutput = {
2648
- ...output,
2649
- body: await parseErrorBody(output.body, context)
2650
- };
2651
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2652
- switch (errorCode) {
2653
- case "ConflictException":
2654
- case "com.amazonaws.mgn#ConflictException":
2655
- throw await de_ConflictExceptionRes(parsedOutput, context);
2656
- case "ResourceNotFoundException":
2657
- case "com.amazonaws.mgn#ResourceNotFoundException":
2658
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2659
- case "UninitializedAccountException":
2660
- case "com.amazonaws.mgn#UninitializedAccountException":
2661
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2662
- default:
2663
- const parsedBody = parsedOutput.body;
2664
- return throwDefaultError({
2665
- output,
2666
- parsedBody,
2667
- errorCode
2668
- });
2669
- }
2670
- }, "de_DeleteJobCommandError");
2671
2334
  var de_DeleteLaunchConfigurationTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
2672
2335
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2673
- return de_DeleteLaunchConfigurationTemplateCommandError(output, context);
2336
+ return de_CommandError(output, context);
2674
2337
  }
2675
2338
  const contents = (0, import_smithy_client.map)({
2676
2339
  $metadata: deserializeMetadata(output)
@@ -2678,34 +2341,9 @@ var de_DeleteLaunchConfigurationTemplateCommand = /* @__PURE__ */ __name(async (
2678
2341
  await (0, import_smithy_client.collectBody)(output.body, context);
2679
2342
  return contents;
2680
2343
  }, "de_DeleteLaunchConfigurationTemplateCommand");
2681
- var de_DeleteLaunchConfigurationTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
2682
- const parsedOutput = {
2683
- ...output,
2684
- body: await parseErrorBody(output.body, context)
2685
- };
2686
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2687
- switch (errorCode) {
2688
- case "ConflictException":
2689
- case "com.amazonaws.mgn#ConflictException":
2690
- throw await de_ConflictExceptionRes(parsedOutput, context);
2691
- case "ResourceNotFoundException":
2692
- case "com.amazonaws.mgn#ResourceNotFoundException":
2693
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2694
- case "UninitializedAccountException":
2695
- case "com.amazonaws.mgn#UninitializedAccountException":
2696
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2697
- default:
2698
- const parsedBody = parsedOutput.body;
2699
- return throwDefaultError({
2700
- output,
2701
- parsedBody,
2702
- errorCode
2703
- });
2704
- }
2705
- }, "de_DeleteLaunchConfigurationTemplateCommandError");
2706
2344
  var de_DeleteReplicationConfigurationTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
2707
2345
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2708
- return de_DeleteReplicationConfigurationTemplateCommandError(output, context);
2346
+ return de_CommandError(output, context);
2709
2347
  }
2710
2348
  const contents = (0, import_smithy_client.map)({
2711
2349
  $metadata: deserializeMetadata(output)
@@ -2713,34 +2351,9 @@ var de_DeleteReplicationConfigurationTemplateCommand = /* @__PURE__ */ __name(as
2713
2351
  await (0, import_smithy_client.collectBody)(output.body, context);
2714
2352
  return contents;
2715
2353
  }, "de_DeleteReplicationConfigurationTemplateCommand");
2716
- var de_DeleteReplicationConfigurationTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
2717
- const parsedOutput = {
2718
- ...output,
2719
- body: await parseErrorBody(output.body, context)
2720
- };
2721
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2722
- switch (errorCode) {
2723
- case "ConflictException":
2724
- case "com.amazonaws.mgn#ConflictException":
2725
- throw await de_ConflictExceptionRes(parsedOutput, context);
2726
- case "ResourceNotFoundException":
2727
- case "com.amazonaws.mgn#ResourceNotFoundException":
2728
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2729
- case "UninitializedAccountException":
2730
- case "com.amazonaws.mgn#UninitializedAccountException":
2731
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2732
- default:
2733
- const parsedBody = parsedOutput.body;
2734
- return throwDefaultError({
2735
- output,
2736
- parsedBody,
2737
- errorCode
2738
- });
2739
- }
2740
- }, "de_DeleteReplicationConfigurationTemplateCommandError");
2741
2354
  var de_DeleteSourceServerCommand = /* @__PURE__ */ __name(async (output, context) => {
2742
2355
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2743
- return de_DeleteSourceServerCommandError(output, context);
2356
+ return de_CommandError(output, context);
2744
2357
  }
2745
2358
  const contents = (0, import_smithy_client.map)({
2746
2359
  $metadata: deserializeMetadata(output)
@@ -2748,34 +2361,9 @@ var de_DeleteSourceServerCommand = /* @__PURE__ */ __name(async (output, context
2748
2361
  await (0, import_smithy_client.collectBody)(output.body, context);
2749
2362
  return contents;
2750
2363
  }, "de_DeleteSourceServerCommand");
2751
- var de_DeleteSourceServerCommandError = /* @__PURE__ */ __name(async (output, context) => {
2752
- const parsedOutput = {
2753
- ...output,
2754
- body: await parseErrorBody(output.body, context)
2755
- };
2756
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2757
- switch (errorCode) {
2758
- case "ConflictException":
2759
- case "com.amazonaws.mgn#ConflictException":
2760
- throw await de_ConflictExceptionRes(parsedOutput, context);
2761
- case "ResourceNotFoundException":
2762
- case "com.amazonaws.mgn#ResourceNotFoundException":
2763
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2764
- case "UninitializedAccountException":
2765
- case "com.amazonaws.mgn#UninitializedAccountException":
2766
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2767
- default:
2768
- const parsedBody = parsedOutput.body;
2769
- return throwDefaultError({
2770
- output,
2771
- parsedBody,
2772
- errorCode
2773
- });
2774
- }
2775
- }, "de_DeleteSourceServerCommandError");
2776
2364
  var de_DeleteVcenterClientCommand = /* @__PURE__ */ __name(async (output, context) => {
2777
2365
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2778
- return de_DeleteVcenterClientCommandError(output, context);
2366
+ return de_CommandError(output, context);
2779
2367
  }
2780
2368
  const contents = (0, import_smithy_client.map)({
2781
2369
  $metadata: deserializeMetadata(output)
@@ -2783,34 +2371,9 @@ var de_DeleteVcenterClientCommand = /* @__PURE__ */ __name(async (output, contex
2783
2371
  await (0, import_smithy_client.collectBody)(output.body, context);
2784
2372
  return contents;
2785
2373
  }, "de_DeleteVcenterClientCommand");
2786
- var de_DeleteVcenterClientCommandError = /* @__PURE__ */ __name(async (output, context) => {
2787
- const parsedOutput = {
2788
- ...output,
2789
- body: await parseErrorBody(output.body, context)
2790
- };
2791
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2792
- switch (errorCode) {
2793
- case "ResourceNotFoundException":
2794
- case "com.amazonaws.mgn#ResourceNotFoundException":
2795
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2796
- case "UninitializedAccountException":
2797
- case "com.amazonaws.mgn#UninitializedAccountException":
2798
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2799
- case "ValidationException":
2800
- case "com.amazonaws.mgn#ValidationException":
2801
- throw await de_ValidationExceptionRes(parsedOutput, context);
2802
- default:
2803
- const parsedBody = parsedOutput.body;
2804
- return throwDefaultError({
2805
- output,
2806
- parsedBody,
2807
- errorCode
2808
- });
2809
- }
2810
- }, "de_DeleteVcenterClientCommandError");
2811
2374
  var de_DeleteWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
2812
2375
  if (output.statusCode !== 204 && output.statusCode >= 300) {
2813
- return de_DeleteWaveCommandError(output, context);
2376
+ return de_CommandError(output, context);
2814
2377
  }
2815
2378
  const contents = (0, import_smithy_client.map)({
2816
2379
  $metadata: deserializeMetadata(output)
@@ -2818,34 +2381,9 @@ var de_DeleteWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
2818
2381
  await (0, import_smithy_client.collectBody)(output.body, context);
2819
2382
  return contents;
2820
2383
  }, "de_DeleteWaveCommand");
2821
- var de_DeleteWaveCommandError = /* @__PURE__ */ __name(async (output, context) => {
2822
- const parsedOutput = {
2823
- ...output,
2824
- body: await parseErrorBody(output.body, context)
2825
- };
2826
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2827
- switch (errorCode) {
2828
- case "ConflictException":
2829
- case "com.amazonaws.mgn#ConflictException":
2830
- throw await de_ConflictExceptionRes(parsedOutput, context);
2831
- case "ResourceNotFoundException":
2832
- case "com.amazonaws.mgn#ResourceNotFoundException":
2833
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2834
- case "UninitializedAccountException":
2835
- case "com.amazonaws.mgn#UninitializedAccountException":
2836
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2837
- default:
2838
- const parsedBody = parsedOutput.body;
2839
- return throwDefaultError({
2840
- output,
2841
- parsedBody,
2842
- errorCode
2843
- });
2844
- }
2845
- }, "de_DeleteWaveCommandError");
2846
2384
  var de_DescribeJobLogItemsCommand = /* @__PURE__ */ __name(async (output, context) => {
2847
2385
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2848
- return de_DescribeJobLogItemsCommandError(output, context);
2386
+ return de_CommandError(output, context);
2849
2387
  }
2850
2388
  const contents = (0, import_smithy_client.map)({
2851
2389
  $metadata: deserializeMetadata(output)
@@ -2858,31 +2396,9 @@ var de_DescribeJobLogItemsCommand = /* @__PURE__ */ __name(async (output, contex
2858
2396
  Object.assign(contents, doc);
2859
2397
  return contents;
2860
2398
  }, "de_DescribeJobLogItemsCommand");
2861
- var de_DescribeJobLogItemsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2862
- const parsedOutput = {
2863
- ...output,
2864
- body: await parseErrorBody(output.body, context)
2865
- };
2866
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2867
- switch (errorCode) {
2868
- case "UninitializedAccountException":
2869
- case "com.amazonaws.mgn#UninitializedAccountException":
2870
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2871
- case "ValidationException":
2872
- case "com.amazonaws.mgn#ValidationException":
2873
- throw await de_ValidationExceptionRes(parsedOutput, context);
2874
- default:
2875
- const parsedBody = parsedOutput.body;
2876
- return throwDefaultError({
2877
- output,
2878
- parsedBody,
2879
- errorCode
2880
- });
2881
- }
2882
- }, "de_DescribeJobLogItemsCommandError");
2883
2399
  var de_DescribeJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
2884
2400
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2885
- return de_DescribeJobsCommandError(output, context);
2401
+ return de_CommandError(output, context);
2886
2402
  }
2887
2403
  const contents = (0, import_smithy_client.map)({
2888
2404
  $metadata: deserializeMetadata(output)
@@ -2895,31 +2411,9 @@ var de_DescribeJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
2895
2411
  Object.assign(contents, doc);
2896
2412
  return contents;
2897
2413
  }, "de_DescribeJobsCommand");
2898
- var de_DescribeJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2899
- const parsedOutput = {
2900
- ...output,
2901
- body: await parseErrorBody(output.body, context)
2902
- };
2903
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2904
- switch (errorCode) {
2905
- case "UninitializedAccountException":
2906
- case "com.amazonaws.mgn#UninitializedAccountException":
2907
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2908
- case "ValidationException":
2909
- case "com.amazonaws.mgn#ValidationException":
2910
- throw await de_ValidationExceptionRes(parsedOutput, context);
2911
- default:
2912
- const parsedBody = parsedOutput.body;
2913
- return throwDefaultError({
2914
- output,
2915
- parsedBody,
2916
- errorCode
2917
- });
2918
- }
2919
- }, "de_DescribeJobsCommandError");
2920
2414
  var de_DescribeLaunchConfigurationTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
2921
2415
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2922
- return de_DescribeLaunchConfigurationTemplatesCommandError(output, context);
2416
+ return de_CommandError(output, context);
2923
2417
  }
2924
2418
  const contents = (0, import_smithy_client.map)({
2925
2419
  $metadata: deserializeMetadata(output)
@@ -2932,34 +2426,9 @@ var de_DescribeLaunchConfigurationTemplatesCommand = /* @__PURE__ */ __name(asyn
2932
2426
  Object.assign(contents, doc);
2933
2427
  return contents;
2934
2428
  }, "de_DescribeLaunchConfigurationTemplatesCommand");
2935
- var de_DescribeLaunchConfigurationTemplatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2936
- const parsedOutput = {
2937
- ...output,
2938
- body: await parseErrorBody(output.body, context)
2939
- };
2940
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2941
- switch (errorCode) {
2942
- case "ResourceNotFoundException":
2943
- case "com.amazonaws.mgn#ResourceNotFoundException":
2944
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2945
- case "UninitializedAccountException":
2946
- case "com.amazonaws.mgn#UninitializedAccountException":
2947
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2948
- case "ValidationException":
2949
- case "com.amazonaws.mgn#ValidationException":
2950
- throw await de_ValidationExceptionRes(parsedOutput, context);
2951
- default:
2952
- const parsedBody = parsedOutput.body;
2953
- return throwDefaultError({
2954
- output,
2955
- parsedBody,
2956
- errorCode
2957
- });
2958
- }
2959
- }, "de_DescribeLaunchConfigurationTemplatesCommandError");
2960
2429
  var de_DescribeReplicationConfigurationTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
2961
2430
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2962
- return de_DescribeReplicationConfigurationTemplatesCommandError(output, context);
2431
+ return de_CommandError(output, context);
2963
2432
  }
2964
2433
  const contents = (0, import_smithy_client.map)({
2965
2434
  $metadata: deserializeMetadata(output)
@@ -2972,34 +2441,9 @@ var de_DescribeReplicationConfigurationTemplatesCommand = /* @__PURE__ */ __name
2972
2441
  Object.assign(contents, doc);
2973
2442
  return contents;
2974
2443
  }, "de_DescribeReplicationConfigurationTemplatesCommand");
2975
- var de_DescribeReplicationConfigurationTemplatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2976
- const parsedOutput = {
2977
- ...output,
2978
- body: await parseErrorBody(output.body, context)
2979
- };
2980
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2981
- switch (errorCode) {
2982
- case "ResourceNotFoundException":
2983
- case "com.amazonaws.mgn#ResourceNotFoundException":
2984
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2985
- case "UninitializedAccountException":
2986
- case "com.amazonaws.mgn#UninitializedAccountException":
2987
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
2988
- case "ValidationException":
2989
- case "com.amazonaws.mgn#ValidationException":
2990
- throw await de_ValidationExceptionRes(parsedOutput, context);
2991
- default:
2992
- const parsedBody = parsedOutput.body;
2993
- return throwDefaultError({
2994
- output,
2995
- parsedBody,
2996
- errorCode
2997
- });
2998
- }
2999
- }, "de_DescribeReplicationConfigurationTemplatesCommandError");
3000
2444
  var de_DescribeSourceServersCommand = /* @__PURE__ */ __name(async (output, context) => {
3001
2445
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3002
- return de_DescribeSourceServersCommandError(output, context);
2446
+ return de_CommandError(output, context);
3003
2447
  }
3004
2448
  const contents = (0, import_smithy_client.map)({
3005
2449
  $metadata: deserializeMetadata(output)
@@ -3012,31 +2456,9 @@ var de_DescribeSourceServersCommand = /* @__PURE__ */ __name(async (output, cont
3012
2456
  Object.assign(contents, doc);
3013
2457
  return contents;
3014
2458
  }, "de_DescribeSourceServersCommand");
3015
- var de_DescribeSourceServersCommandError = /* @__PURE__ */ __name(async (output, context) => {
3016
- const parsedOutput = {
3017
- ...output,
3018
- body: await parseErrorBody(output.body, context)
3019
- };
3020
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3021
- switch (errorCode) {
3022
- case "UninitializedAccountException":
3023
- case "com.amazonaws.mgn#UninitializedAccountException":
3024
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3025
- case "ValidationException":
3026
- case "com.amazonaws.mgn#ValidationException":
3027
- throw await de_ValidationExceptionRes(parsedOutput, context);
3028
- default:
3029
- const parsedBody = parsedOutput.body;
3030
- return throwDefaultError({
3031
- output,
3032
- parsedBody,
3033
- errorCode
3034
- });
3035
- }
3036
- }, "de_DescribeSourceServersCommandError");
3037
2459
  var de_DescribeVcenterClientsCommand = /* @__PURE__ */ __name(async (output, context) => {
3038
2460
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3039
- return de_DescribeVcenterClientsCommandError(output, context);
2461
+ return de_CommandError(output, context);
3040
2462
  }
3041
2463
  const contents = (0, import_smithy_client.map)({
3042
2464
  $metadata: deserializeMetadata(output)
@@ -3049,34 +2471,9 @@ var de_DescribeVcenterClientsCommand = /* @__PURE__ */ __name(async (output, con
3049
2471
  Object.assign(contents, doc);
3050
2472
  return contents;
3051
2473
  }, "de_DescribeVcenterClientsCommand");
3052
- var de_DescribeVcenterClientsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3053
- const parsedOutput = {
3054
- ...output,
3055
- body: await parseErrorBody(output.body, context)
3056
- };
3057
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3058
- switch (errorCode) {
3059
- case "ResourceNotFoundException":
3060
- case "com.amazonaws.mgn#ResourceNotFoundException":
3061
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3062
- case "UninitializedAccountException":
3063
- case "com.amazonaws.mgn#UninitializedAccountException":
3064
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3065
- case "ValidationException":
3066
- case "com.amazonaws.mgn#ValidationException":
3067
- throw await de_ValidationExceptionRes(parsedOutput, context);
3068
- default:
3069
- const parsedBody = parsedOutput.body;
3070
- return throwDefaultError({
3071
- output,
3072
- parsedBody,
3073
- errorCode
3074
- });
3075
- }
3076
- }, "de_DescribeVcenterClientsCommandError");
3077
2474
  var de_DisassociateApplicationsCommand = /* @__PURE__ */ __name(async (output, context) => {
3078
2475
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3079
- return de_DisassociateApplicationsCommandError(output, context);
2476
+ return de_CommandError(output, context);
3080
2477
  }
3081
2478
  const contents = (0, import_smithy_client.map)({
3082
2479
  $metadata: deserializeMetadata(output)
@@ -3084,34 +2481,9 @@ var de_DisassociateApplicationsCommand = /* @__PURE__ */ __name(async (output, c
3084
2481
  await (0, import_smithy_client.collectBody)(output.body, context);
3085
2482
  return contents;
3086
2483
  }, "de_DisassociateApplicationsCommand");
3087
- var de_DisassociateApplicationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3088
- const parsedOutput = {
3089
- ...output,
3090
- body: await parseErrorBody(output.body, context)
3091
- };
3092
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3093
- switch (errorCode) {
3094
- case "ConflictException":
3095
- case "com.amazonaws.mgn#ConflictException":
3096
- throw await de_ConflictExceptionRes(parsedOutput, context);
3097
- case "ResourceNotFoundException":
3098
- case "com.amazonaws.mgn#ResourceNotFoundException":
3099
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3100
- case "UninitializedAccountException":
3101
- case "com.amazonaws.mgn#UninitializedAccountException":
3102
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3103
- default:
3104
- const parsedBody = parsedOutput.body;
3105
- return throwDefaultError({
3106
- output,
3107
- parsedBody,
3108
- errorCode
3109
- });
3110
- }
3111
- }, "de_DisassociateApplicationsCommandError");
3112
2484
  var de_DisassociateSourceServersCommand = /* @__PURE__ */ __name(async (output, context) => {
3113
2485
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3114
- return de_DisassociateSourceServersCommandError(output, context);
2486
+ return de_CommandError(output, context);
3115
2487
  }
3116
2488
  const contents = (0, import_smithy_client.map)({
3117
2489
  $metadata: deserializeMetadata(output)
@@ -3119,34 +2491,9 @@ var de_DisassociateSourceServersCommand = /* @__PURE__ */ __name(async (output,
3119
2491
  await (0, import_smithy_client.collectBody)(output.body, context);
3120
2492
  return contents;
3121
2493
  }, "de_DisassociateSourceServersCommand");
3122
- var de_DisassociateSourceServersCommandError = /* @__PURE__ */ __name(async (output, context) => {
3123
- const parsedOutput = {
3124
- ...output,
3125
- body: await parseErrorBody(output.body, context)
3126
- };
3127
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3128
- switch (errorCode) {
3129
- case "ConflictException":
3130
- case "com.amazonaws.mgn#ConflictException":
3131
- throw await de_ConflictExceptionRes(parsedOutput, context);
3132
- case "ResourceNotFoundException":
3133
- case "com.amazonaws.mgn#ResourceNotFoundException":
3134
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3135
- case "UninitializedAccountException":
3136
- case "com.amazonaws.mgn#UninitializedAccountException":
3137
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3138
- default:
3139
- const parsedBody = parsedOutput.body;
3140
- return throwDefaultError({
3141
- output,
3142
- parsedBody,
3143
- errorCode
3144
- });
3145
- }
3146
- }, "de_DisassociateSourceServersCommandError");
3147
2494
  var de_DisconnectFromServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
3148
2495
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3149
- return de_DisconnectFromServiceCommandError(output, context);
2496
+ return de_CommandError(output, context);
3150
2497
  }
3151
2498
  const contents = (0, import_smithy_client.map)({
3152
2499
  $metadata: deserializeMetadata(output)
@@ -3171,34 +2518,9 @@ var de_DisconnectFromServiceCommand = /* @__PURE__ */ __name(async (output, cont
3171
2518
  Object.assign(contents, doc);
3172
2519
  return contents;
3173
2520
  }, "de_DisconnectFromServiceCommand");
3174
- var de_DisconnectFromServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
3175
- const parsedOutput = {
3176
- ...output,
3177
- body: await parseErrorBody(output.body, context)
3178
- };
3179
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3180
- switch (errorCode) {
3181
- case "ConflictException":
3182
- case "com.amazonaws.mgn#ConflictException":
3183
- throw await de_ConflictExceptionRes(parsedOutput, context);
3184
- case "ResourceNotFoundException":
3185
- case "com.amazonaws.mgn#ResourceNotFoundException":
3186
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3187
- case "UninitializedAccountException":
3188
- case "com.amazonaws.mgn#UninitializedAccountException":
3189
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3190
- default:
3191
- const parsedBody = parsedOutput.body;
3192
- return throwDefaultError({
3193
- output,
3194
- parsedBody,
3195
- errorCode
3196
- });
3197
- }
3198
- }, "de_DisconnectFromServiceCommandError");
3199
2521
  var de_FinalizeCutoverCommand = /* @__PURE__ */ __name(async (output, context) => {
3200
2522
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3201
- return de_FinalizeCutoverCommandError(output, context);
2523
+ return de_CommandError(output, context);
3202
2524
  }
3203
2525
  const contents = (0, import_smithy_client.map)({
3204
2526
  $metadata: deserializeMetadata(output)
@@ -3223,37 +2545,9 @@ var de_FinalizeCutoverCommand = /* @__PURE__ */ __name(async (output, context) =
3223
2545
  Object.assign(contents, doc);
3224
2546
  return contents;
3225
2547
  }, "de_FinalizeCutoverCommand");
3226
- var de_FinalizeCutoverCommandError = /* @__PURE__ */ __name(async (output, context) => {
3227
- const parsedOutput = {
3228
- ...output,
3229
- body: await parseErrorBody(output.body, context)
3230
- };
3231
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3232
- switch (errorCode) {
3233
- case "ConflictException":
3234
- case "com.amazonaws.mgn#ConflictException":
3235
- throw await de_ConflictExceptionRes(parsedOutput, context);
3236
- case "ResourceNotFoundException":
3237
- case "com.amazonaws.mgn#ResourceNotFoundException":
3238
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3239
- case "UninitializedAccountException":
3240
- case "com.amazonaws.mgn#UninitializedAccountException":
3241
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3242
- case "ValidationException":
3243
- case "com.amazonaws.mgn#ValidationException":
3244
- throw await de_ValidationExceptionRes(parsedOutput, context);
3245
- default:
3246
- const parsedBody = parsedOutput.body;
3247
- return throwDefaultError({
3248
- output,
3249
- parsedBody,
3250
- errorCode
3251
- });
3252
- }
3253
- }, "de_FinalizeCutoverCommandError");
3254
2548
  var de_GetLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
3255
2549
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3256
- return de_GetLaunchConfigurationCommandError(output, context);
2550
+ return de_CommandError(output, context);
3257
2551
  }
3258
2552
  const contents = (0, import_smithy_client.map)({
3259
2553
  $metadata: deserializeMetadata(output)
@@ -3276,31 +2570,9 @@ var de_GetLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output, con
3276
2570
  Object.assign(contents, doc);
3277
2571
  return contents;
3278
2572
  }, "de_GetLaunchConfigurationCommand");
3279
- var de_GetLaunchConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
3280
- const parsedOutput = {
3281
- ...output,
3282
- body: await parseErrorBody(output.body, context)
3283
- };
3284
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3285
- switch (errorCode) {
3286
- case "ResourceNotFoundException":
3287
- case "com.amazonaws.mgn#ResourceNotFoundException":
3288
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3289
- case "UninitializedAccountException":
3290
- case "com.amazonaws.mgn#UninitializedAccountException":
3291
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3292
- default:
3293
- const parsedBody = parsedOutput.body;
3294
- return throwDefaultError({
3295
- output,
3296
- parsedBody,
3297
- errorCode
3298
- });
3299
- }
3300
- }, "de_GetLaunchConfigurationCommandError");
3301
2573
  var de_GetReplicationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
3302
2574
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3303
- return de_GetReplicationConfigurationCommandError(output, context);
2575
+ return de_CommandError(output, context);
3304
2576
  }
3305
2577
  const contents = (0, import_smithy_client.map)({
3306
2578
  $metadata: deserializeMetadata(output)
@@ -3327,31 +2599,9 @@ var de_GetReplicationConfigurationCommand = /* @__PURE__ */ __name(async (output
3327
2599
  Object.assign(contents, doc);
3328
2600
  return contents;
3329
2601
  }, "de_GetReplicationConfigurationCommand");
3330
- var de_GetReplicationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
3331
- const parsedOutput = {
3332
- ...output,
3333
- body: await parseErrorBody(output.body, context)
3334
- };
3335
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3336
- switch (errorCode) {
3337
- case "ResourceNotFoundException":
3338
- case "com.amazonaws.mgn#ResourceNotFoundException":
3339
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3340
- case "UninitializedAccountException":
3341
- case "com.amazonaws.mgn#UninitializedAccountException":
3342
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3343
- default:
3344
- const parsedBody = parsedOutput.body;
3345
- return throwDefaultError({
3346
- output,
3347
- parsedBody,
3348
- errorCode
3349
- });
3350
- }
3351
- }, "de_GetReplicationConfigurationCommandError");
3352
2602
  var de_InitializeServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
3353
2603
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3354
- return de_InitializeServiceCommandError(output, context);
2604
+ return de_CommandError(output, context);
3355
2605
  }
3356
2606
  const contents = (0, import_smithy_client.map)({
3357
2607
  $metadata: deserializeMetadata(output)
@@ -3359,31 +2609,9 @@ var de_InitializeServiceCommand = /* @__PURE__ */ __name(async (output, context)
3359
2609
  await (0, import_smithy_client.collectBody)(output.body, context);
3360
2610
  return contents;
3361
2611
  }, "de_InitializeServiceCommand");
3362
- var de_InitializeServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
3363
- const parsedOutput = {
3364
- ...output,
3365
- body: await parseErrorBody(output.body, context)
3366
- };
3367
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3368
- switch (errorCode) {
3369
- case "AccessDeniedException":
3370
- case "com.amazonaws.mgn#AccessDeniedException":
3371
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3372
- case "ValidationException":
3373
- case "com.amazonaws.mgn#ValidationException":
3374
- throw await de_ValidationExceptionRes(parsedOutput, context);
3375
- default:
3376
- const parsedBody = parsedOutput.body;
3377
- return throwDefaultError({
3378
- output,
3379
- parsedBody,
3380
- errorCode
3381
- });
3382
- }
3383
- }, "de_InitializeServiceCommandError");
3384
2612
  var de_ListApplicationsCommand = /* @__PURE__ */ __name(async (output, context) => {
3385
2613
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3386
- return de_ListApplicationsCommandError(output, context);
2614
+ return de_CommandError(output, context);
3387
2615
  }
3388
2616
  const contents = (0, import_smithy_client.map)({
3389
2617
  $metadata: deserializeMetadata(output)
@@ -3396,28 +2624,9 @@ var de_ListApplicationsCommand = /* @__PURE__ */ __name(async (output, context)
3396
2624
  Object.assign(contents, doc);
3397
2625
  return contents;
3398
2626
  }, "de_ListApplicationsCommand");
3399
- var de_ListApplicationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3400
- const parsedOutput = {
3401
- ...output,
3402
- body: await parseErrorBody(output.body, context)
3403
- };
3404
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3405
- switch (errorCode) {
3406
- case "UninitializedAccountException":
3407
- case "com.amazonaws.mgn#UninitializedAccountException":
3408
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3409
- default:
3410
- const parsedBody = parsedOutput.body;
3411
- return throwDefaultError({
3412
- output,
3413
- parsedBody,
3414
- errorCode
3415
- });
3416
- }
3417
- }, "de_ListApplicationsCommandError");
3418
2627
  var de_ListConnectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
3419
2628
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3420
- return de_ListConnectorsCommandError(output, context);
2629
+ return de_CommandError(output, context);
3421
2630
  }
3422
2631
  const contents = (0, import_smithy_client.map)({
3423
2632
  $metadata: deserializeMetadata(output)
@@ -3430,31 +2639,9 @@ var de_ListConnectorsCommand = /* @__PURE__ */ __name(async (output, context) =>
3430
2639
  Object.assign(contents, doc);
3431
2640
  return contents;
3432
2641
  }, "de_ListConnectorsCommand");
3433
- var de_ListConnectorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3434
- const parsedOutput = {
3435
- ...output,
3436
- body: await parseErrorBody(output.body, context)
3437
- };
3438
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3439
- switch (errorCode) {
3440
- case "UninitializedAccountException":
3441
- case "com.amazonaws.mgn#UninitializedAccountException":
3442
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3443
- case "ValidationException":
3444
- case "com.amazonaws.mgn#ValidationException":
3445
- throw await de_ValidationExceptionRes(parsedOutput, context);
3446
- default:
3447
- const parsedBody = parsedOutput.body;
3448
- return throwDefaultError({
3449
- output,
3450
- parsedBody,
3451
- errorCode
3452
- });
3453
- }
3454
- }, "de_ListConnectorsCommandError");
3455
2642
  var de_ListExportErrorsCommand = /* @__PURE__ */ __name(async (output, context) => {
3456
2643
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3457
- return de_ListExportErrorsCommandError(output, context);
2644
+ return de_CommandError(output, context);
3458
2645
  }
3459
2646
  const contents = (0, import_smithy_client.map)({
3460
2647
  $metadata: deserializeMetadata(output)
@@ -3467,31 +2654,9 @@ var de_ListExportErrorsCommand = /* @__PURE__ */ __name(async (output, context)
3467
2654
  Object.assign(contents, doc);
3468
2655
  return contents;
3469
2656
  }, "de_ListExportErrorsCommand");
3470
- var de_ListExportErrorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3471
- const parsedOutput = {
3472
- ...output,
3473
- body: await parseErrorBody(output.body, context)
3474
- };
3475
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3476
- switch (errorCode) {
3477
- case "UninitializedAccountException":
3478
- case "com.amazonaws.mgn#UninitializedAccountException":
3479
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3480
- case "ValidationException":
3481
- case "com.amazonaws.mgn#ValidationException":
3482
- throw await de_ValidationExceptionRes(parsedOutput, context);
3483
- default:
3484
- const parsedBody = parsedOutput.body;
3485
- return throwDefaultError({
3486
- output,
3487
- parsedBody,
3488
- errorCode
3489
- });
3490
- }
3491
- }, "de_ListExportErrorsCommandError");
3492
2657
  var de_ListExportsCommand = /* @__PURE__ */ __name(async (output, context) => {
3493
2658
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3494
- return de_ListExportsCommandError(output, context);
2659
+ return de_CommandError(output, context);
3495
2660
  }
3496
2661
  const contents = (0, import_smithy_client.map)({
3497
2662
  $metadata: deserializeMetadata(output)
@@ -3504,28 +2669,9 @@ var de_ListExportsCommand = /* @__PURE__ */ __name(async (output, context) => {
3504
2669
  Object.assign(contents, doc);
3505
2670
  return contents;
3506
2671
  }, "de_ListExportsCommand");
3507
- var de_ListExportsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3508
- const parsedOutput = {
3509
- ...output,
3510
- body: await parseErrorBody(output.body, context)
3511
- };
3512
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3513
- switch (errorCode) {
3514
- case "UninitializedAccountException":
3515
- case "com.amazonaws.mgn#UninitializedAccountException":
3516
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3517
- default:
3518
- const parsedBody = parsedOutput.body;
3519
- return throwDefaultError({
3520
- output,
3521
- parsedBody,
3522
- errorCode
3523
- });
3524
- }
3525
- }, "de_ListExportsCommandError");
3526
2672
  var de_ListImportErrorsCommand = /* @__PURE__ */ __name(async (output, context) => {
3527
2673
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3528
- return de_ListImportErrorsCommandError(output, context);
2674
+ return de_CommandError(output, context);
3529
2675
  }
3530
2676
  const contents = (0, import_smithy_client.map)({
3531
2677
  $metadata: deserializeMetadata(output)
@@ -3538,31 +2684,9 @@ var de_ListImportErrorsCommand = /* @__PURE__ */ __name(async (output, context)
3538
2684
  Object.assign(contents, doc);
3539
2685
  return contents;
3540
2686
  }, "de_ListImportErrorsCommand");
3541
- var de_ListImportErrorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3542
- const parsedOutput = {
3543
- ...output,
3544
- body: await parseErrorBody(output.body, context)
3545
- };
3546
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3547
- switch (errorCode) {
3548
- case "UninitializedAccountException":
3549
- case "com.amazonaws.mgn#UninitializedAccountException":
3550
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3551
- case "ValidationException":
3552
- case "com.amazonaws.mgn#ValidationException":
3553
- throw await de_ValidationExceptionRes(parsedOutput, context);
3554
- default:
3555
- const parsedBody = parsedOutput.body;
3556
- return throwDefaultError({
3557
- output,
3558
- parsedBody,
3559
- errorCode
3560
- });
3561
- }
3562
- }, "de_ListImportErrorsCommandError");
3563
2687
  var de_ListImportsCommand = /* @__PURE__ */ __name(async (output, context) => {
3564
2688
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3565
- return de_ListImportsCommandError(output, context);
2689
+ return de_CommandError(output, context);
3566
2690
  }
3567
2691
  const contents = (0, import_smithy_client.map)({
3568
2692
  $metadata: deserializeMetadata(output)
@@ -3575,31 +2699,9 @@ var de_ListImportsCommand = /* @__PURE__ */ __name(async (output, context) => {
3575
2699
  Object.assign(contents, doc);
3576
2700
  return contents;
3577
2701
  }, "de_ListImportsCommand");
3578
- var de_ListImportsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3579
- const parsedOutput = {
3580
- ...output,
3581
- body: await parseErrorBody(output.body, context)
3582
- };
3583
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3584
- switch (errorCode) {
3585
- case "UninitializedAccountException":
3586
- case "com.amazonaws.mgn#UninitializedAccountException":
3587
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3588
- case "ValidationException":
3589
- case "com.amazonaws.mgn#ValidationException":
3590
- throw await de_ValidationExceptionRes(parsedOutput, context);
3591
- default:
3592
- const parsedBody = parsedOutput.body;
3593
- return throwDefaultError({
3594
- output,
3595
- parsedBody,
3596
- errorCode
3597
- });
3598
- }
3599
- }, "de_ListImportsCommandError");
3600
2702
  var de_ListManagedAccountsCommand = /* @__PURE__ */ __name(async (output, context) => {
3601
2703
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3602
- return de_ListManagedAccountsCommandError(output, context);
2704
+ return de_CommandError(output, context);
3603
2705
  }
3604
2706
  const contents = (0, import_smithy_client.map)({
3605
2707
  $metadata: deserializeMetadata(output)
@@ -3612,31 +2714,9 @@ var de_ListManagedAccountsCommand = /* @__PURE__ */ __name(async (output, contex
3612
2714
  Object.assign(contents, doc);
3613
2715
  return contents;
3614
2716
  }, "de_ListManagedAccountsCommand");
3615
- var de_ListManagedAccountsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3616
- const parsedOutput = {
3617
- ...output,
3618
- body: await parseErrorBody(output.body, context)
3619
- };
3620
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3621
- switch (errorCode) {
3622
- case "UninitializedAccountException":
3623
- case "com.amazonaws.mgn#UninitializedAccountException":
3624
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3625
- case "ValidationException":
3626
- case "com.amazonaws.mgn#ValidationException":
3627
- throw await de_ValidationExceptionRes(parsedOutput, context);
3628
- default:
3629
- const parsedBody = parsedOutput.body;
3630
- return throwDefaultError({
3631
- output,
3632
- parsedBody,
3633
- errorCode
3634
- });
3635
- }
3636
- }, "de_ListManagedAccountsCommandError");
3637
2717
  var de_ListSourceServerActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
3638
2718
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3639
- return de_ListSourceServerActionsCommandError(output, context);
2719
+ return de_CommandError(output, context);
3640
2720
  }
3641
2721
  const contents = (0, import_smithy_client.map)({
3642
2722
  $metadata: deserializeMetadata(output)
@@ -3649,31 +2729,9 @@ var de_ListSourceServerActionsCommand = /* @__PURE__ */ __name(async (output, co
3649
2729
  Object.assign(contents, doc);
3650
2730
  return contents;
3651
2731
  }, "de_ListSourceServerActionsCommand");
3652
- var de_ListSourceServerActionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3653
- const parsedOutput = {
3654
- ...output,
3655
- body: await parseErrorBody(output.body, context)
3656
- };
3657
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3658
- switch (errorCode) {
3659
- case "ResourceNotFoundException":
3660
- case "com.amazonaws.mgn#ResourceNotFoundException":
3661
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3662
- case "UninitializedAccountException":
3663
- case "com.amazonaws.mgn#UninitializedAccountException":
3664
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3665
- default:
3666
- const parsedBody = parsedOutput.body;
3667
- return throwDefaultError({
3668
- output,
3669
- parsedBody,
3670
- errorCode
3671
- });
3672
- }
3673
- }, "de_ListSourceServerActionsCommandError");
3674
2732
  var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
3675
2733
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3676
- return de_ListTagsForResourceCommandError(output, context);
2734
+ return de_CommandError(output, context);
3677
2735
  }
3678
2736
  const contents = (0, import_smithy_client.map)({
3679
2737
  $metadata: deserializeMetadata(output)
@@ -3685,77 +2743,9 @@ var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, contex
3685
2743
  Object.assign(contents, doc);
3686
2744
  return contents;
3687
2745
  }, "de_ListTagsForResourceCommand");
3688
- var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
3689
- const parsedOutput = {
3690
- ...output,
3691
- body: await parseErrorBody(output.body, context)
3692
- };
3693
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3694
- switch (errorCode) {
3695
- case "AccessDeniedException":
3696
- case "com.amazonaws.mgn#AccessDeniedException":
3697
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3698
- case "InternalServerException":
3699
- case "com.amazonaws.mgn#InternalServerException":
3700
- throw await de_InternalServerExceptionRes(parsedOutput, context);
3701
- case "ResourceNotFoundException":
3702
- case "com.amazonaws.mgn#ResourceNotFoundException":
3703
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3704
- case "ThrottlingException":
3705
- case "com.amazonaws.mgn#ThrottlingException":
3706
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
3707
- case "ValidationException":
3708
- case "com.amazonaws.mgn#ValidationException":
3709
- throw await de_ValidationExceptionRes(parsedOutput, context);
3710
- default:
3711
- const parsedBody = parsedOutput.body;
3712
- return throwDefaultError({
3713
- output,
3714
- parsedBody,
3715
- errorCode
3716
- });
3717
- }
3718
- }, "de_ListTagsForResourceCommandError");
3719
2746
  var de_ListTemplateActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
3720
2747
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3721
- return de_ListTemplateActionsCommandError(output, context);
3722
- }
3723
- const contents = (0, import_smithy_client.map)({
3724
- $metadata: deserializeMetadata(output)
3725
- });
3726
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
3727
- const doc = (0, import_smithy_client.take)(data, {
3728
- items: import_smithy_client._json,
3729
- nextToken: import_smithy_client.expectString
3730
- });
3731
- Object.assign(contents, doc);
3732
- return contents;
3733
- }, "de_ListTemplateActionsCommand");
3734
- var de_ListTemplateActionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3735
- const parsedOutput = {
3736
- ...output,
3737
- body: await parseErrorBody(output.body, context)
3738
- };
3739
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3740
- switch (errorCode) {
3741
- case "ResourceNotFoundException":
3742
- case "com.amazonaws.mgn#ResourceNotFoundException":
3743
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3744
- case "UninitializedAccountException":
3745
- case "com.amazonaws.mgn#UninitializedAccountException":
3746
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3747
- default:
3748
- const parsedBody = parsedOutput.body;
3749
- return throwDefaultError({
3750
- output,
3751
- parsedBody,
3752
- errorCode
3753
- });
3754
- }
3755
- }, "de_ListTemplateActionsCommandError");
3756
- var de_ListWavesCommand = /* @__PURE__ */ __name(async (output, context) => {
3757
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3758
- return de_ListWavesCommandError(output, context);
2748
+ return de_CommandError(output, context);
3759
2749
  }
3760
2750
  const contents = (0, import_smithy_client.map)({
3761
2751
  $metadata: deserializeMetadata(output)
@@ -3765,31 +2755,27 @@ var de_ListWavesCommand = /* @__PURE__ */ __name(async (output, context) => {
3765
2755
  items: import_smithy_client._json,
3766
2756
  nextToken: import_smithy_client.expectString
3767
2757
  });
3768
- Object.assign(contents, doc);
3769
- return contents;
3770
- }, "de_ListWavesCommand");
3771
- var de_ListWavesCommandError = /* @__PURE__ */ __name(async (output, context) => {
3772
- const parsedOutput = {
3773
- ...output,
3774
- body: await parseErrorBody(output.body, context)
3775
- };
3776
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3777
- switch (errorCode) {
3778
- case "UninitializedAccountException":
3779
- case "com.amazonaws.mgn#UninitializedAccountException":
3780
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3781
- default:
3782
- const parsedBody = parsedOutput.body;
3783
- return throwDefaultError({
3784
- output,
3785
- parsedBody,
3786
- errorCode
3787
- });
2758
+ Object.assign(contents, doc);
2759
+ return contents;
2760
+ }, "de_ListTemplateActionsCommand");
2761
+ var de_ListWavesCommand = /* @__PURE__ */ __name(async (output, context) => {
2762
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
2763
+ return de_CommandError(output, context);
3788
2764
  }
3789
- }, "de_ListWavesCommandError");
2765
+ const contents = (0, import_smithy_client.map)({
2766
+ $metadata: deserializeMetadata(output)
2767
+ });
2768
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
2769
+ const doc = (0, import_smithy_client.take)(data, {
2770
+ items: import_smithy_client._json,
2771
+ nextToken: import_smithy_client.expectString
2772
+ });
2773
+ Object.assign(contents, doc);
2774
+ return contents;
2775
+ }, "de_ListWavesCommand");
3790
2776
  var de_MarkAsArchivedCommand = /* @__PURE__ */ __name(async (output, context) => {
3791
2777
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3792
- return de_MarkAsArchivedCommandError(output, context);
2778
+ return de_CommandError(output, context);
3793
2779
  }
3794
2780
  const contents = (0, import_smithy_client.map)({
3795
2781
  $metadata: deserializeMetadata(output)
@@ -3814,34 +2800,9 @@ var de_MarkAsArchivedCommand = /* @__PURE__ */ __name(async (output, context) =>
3814
2800
  Object.assign(contents, doc);
3815
2801
  return contents;
3816
2802
  }, "de_MarkAsArchivedCommand");
3817
- var de_MarkAsArchivedCommandError = /* @__PURE__ */ __name(async (output, context) => {
3818
- const parsedOutput = {
3819
- ...output,
3820
- body: await parseErrorBody(output.body, context)
3821
- };
3822
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3823
- switch (errorCode) {
3824
- case "ConflictException":
3825
- case "com.amazonaws.mgn#ConflictException":
3826
- throw await de_ConflictExceptionRes(parsedOutput, context);
3827
- case "ResourceNotFoundException":
3828
- case "com.amazonaws.mgn#ResourceNotFoundException":
3829
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3830
- case "UninitializedAccountException":
3831
- case "com.amazonaws.mgn#UninitializedAccountException":
3832
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3833
- default:
3834
- const parsedBody = parsedOutput.body;
3835
- return throwDefaultError({
3836
- output,
3837
- parsedBody,
3838
- errorCode
3839
- });
3840
- }
3841
- }, "de_MarkAsArchivedCommandError");
3842
2803
  var de_PauseReplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
3843
2804
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3844
- return de_PauseReplicationCommandError(output, context);
2805
+ return de_CommandError(output, context);
3845
2806
  }
3846
2807
  const contents = (0, import_smithy_client.map)({
3847
2808
  $metadata: deserializeMetadata(output)
@@ -3866,40 +2827,9 @@ var de_PauseReplicationCommand = /* @__PURE__ */ __name(async (output, context)
3866
2827
  Object.assign(contents, doc);
3867
2828
  return contents;
3868
2829
  }, "de_PauseReplicationCommand");
3869
- var de_PauseReplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
3870
- const parsedOutput = {
3871
- ...output,
3872
- body: await parseErrorBody(output.body, context)
3873
- };
3874
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3875
- switch (errorCode) {
3876
- case "ConflictException":
3877
- case "com.amazonaws.mgn#ConflictException":
3878
- throw await de_ConflictExceptionRes(parsedOutput, context);
3879
- case "ResourceNotFoundException":
3880
- case "com.amazonaws.mgn#ResourceNotFoundException":
3881
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3882
- case "ServiceQuotaExceededException":
3883
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
3884
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
3885
- case "UninitializedAccountException":
3886
- case "com.amazonaws.mgn#UninitializedAccountException":
3887
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3888
- case "ValidationException":
3889
- case "com.amazonaws.mgn#ValidationException":
3890
- throw await de_ValidationExceptionRes(parsedOutput, context);
3891
- default:
3892
- const parsedBody = parsedOutput.body;
3893
- return throwDefaultError({
3894
- output,
3895
- parsedBody,
3896
- errorCode
3897
- });
3898
- }
3899
- }, "de_PauseReplicationCommandError");
3900
2830
  var de_PutSourceServerActionCommand = /* @__PURE__ */ __name(async (output, context) => {
3901
2831
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3902
- return de_PutSourceServerActionCommandError(output, context);
2832
+ return de_CommandError(output, context);
3903
2833
  }
3904
2834
  const contents = (0, import_smithy_client.map)({
3905
2835
  $metadata: deserializeMetadata(output)
@@ -3922,37 +2852,9 @@ var de_PutSourceServerActionCommand = /* @__PURE__ */ __name(async (output, cont
3922
2852
  Object.assign(contents, doc);
3923
2853
  return contents;
3924
2854
  }, "de_PutSourceServerActionCommand");
3925
- var de_PutSourceServerActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
3926
- const parsedOutput = {
3927
- ...output,
3928
- body: await parseErrorBody(output.body, context)
3929
- };
3930
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3931
- switch (errorCode) {
3932
- case "ConflictException":
3933
- case "com.amazonaws.mgn#ConflictException":
3934
- throw await de_ConflictExceptionRes(parsedOutput, context);
3935
- case "ResourceNotFoundException":
3936
- case "com.amazonaws.mgn#ResourceNotFoundException":
3937
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3938
- case "UninitializedAccountException":
3939
- case "com.amazonaws.mgn#UninitializedAccountException":
3940
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3941
- case "ValidationException":
3942
- case "com.amazonaws.mgn#ValidationException":
3943
- throw await de_ValidationExceptionRes(parsedOutput, context);
3944
- default:
3945
- const parsedBody = parsedOutput.body;
3946
- return throwDefaultError({
3947
- output,
3948
- parsedBody,
3949
- errorCode
3950
- });
3951
- }
3952
- }, "de_PutSourceServerActionCommandError");
3953
2855
  var de_PutTemplateActionCommand = /* @__PURE__ */ __name(async (output, context) => {
3954
2856
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3955
- return de_PutTemplateActionCommandError(output, context);
2857
+ return de_CommandError(output, context);
3956
2858
  }
3957
2859
  const contents = (0, import_smithy_client.map)({
3958
2860
  $metadata: deserializeMetadata(output)
@@ -3976,37 +2878,9 @@ var de_PutTemplateActionCommand = /* @__PURE__ */ __name(async (output, context)
3976
2878
  Object.assign(contents, doc);
3977
2879
  return contents;
3978
2880
  }, "de_PutTemplateActionCommand");
3979
- var de_PutTemplateActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
3980
- const parsedOutput = {
3981
- ...output,
3982
- body: await parseErrorBody(output.body, context)
3983
- };
3984
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3985
- switch (errorCode) {
3986
- case "ConflictException":
3987
- case "com.amazonaws.mgn#ConflictException":
3988
- throw await de_ConflictExceptionRes(parsedOutput, context);
3989
- case "ResourceNotFoundException":
3990
- case "com.amazonaws.mgn#ResourceNotFoundException":
3991
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3992
- case "UninitializedAccountException":
3993
- case "com.amazonaws.mgn#UninitializedAccountException":
3994
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3995
- case "ValidationException":
3996
- case "com.amazonaws.mgn#ValidationException":
3997
- throw await de_ValidationExceptionRes(parsedOutput, context);
3998
- default:
3999
- const parsedBody = parsedOutput.body;
4000
- return throwDefaultError({
4001
- output,
4002
- parsedBody,
4003
- errorCode
4004
- });
4005
- }
4006
- }, "de_PutTemplateActionCommandError");
4007
2881
  var de_RemoveSourceServerActionCommand = /* @__PURE__ */ __name(async (output, context) => {
4008
2882
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4009
- return de_RemoveSourceServerActionCommandError(output, context);
2883
+ return de_CommandError(output, context);
4010
2884
  }
4011
2885
  const contents = (0, import_smithy_client.map)({
4012
2886
  $metadata: deserializeMetadata(output)
@@ -4014,34 +2888,9 @@ var de_RemoveSourceServerActionCommand = /* @__PURE__ */ __name(async (output, c
4014
2888
  await (0, import_smithy_client.collectBody)(output.body, context);
4015
2889
  return contents;
4016
2890
  }, "de_RemoveSourceServerActionCommand");
4017
- var de_RemoveSourceServerActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
4018
- const parsedOutput = {
4019
- ...output,
4020
- body: await parseErrorBody(output.body, context)
4021
- };
4022
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4023
- switch (errorCode) {
4024
- case "ResourceNotFoundException":
4025
- case "com.amazonaws.mgn#ResourceNotFoundException":
4026
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4027
- case "UninitializedAccountException":
4028
- case "com.amazonaws.mgn#UninitializedAccountException":
4029
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4030
- case "ValidationException":
4031
- case "com.amazonaws.mgn#ValidationException":
4032
- throw await de_ValidationExceptionRes(parsedOutput, context);
4033
- default:
4034
- const parsedBody = parsedOutput.body;
4035
- return throwDefaultError({
4036
- output,
4037
- parsedBody,
4038
- errorCode
4039
- });
4040
- }
4041
- }, "de_RemoveSourceServerActionCommandError");
4042
2891
  var de_RemoveTemplateActionCommand = /* @__PURE__ */ __name(async (output, context) => {
4043
2892
  if (output.statusCode !== 204 && output.statusCode >= 300) {
4044
- return de_RemoveTemplateActionCommandError(output, context);
2893
+ return de_CommandError(output, context);
4045
2894
  }
4046
2895
  const contents = (0, import_smithy_client.map)({
4047
2896
  $metadata: deserializeMetadata(output)
@@ -4049,34 +2898,9 @@ var de_RemoveTemplateActionCommand = /* @__PURE__ */ __name(async (output, conte
4049
2898
  await (0, import_smithy_client.collectBody)(output.body, context);
4050
2899
  return contents;
4051
2900
  }, "de_RemoveTemplateActionCommand");
4052
- var de_RemoveTemplateActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
4053
- const parsedOutput = {
4054
- ...output,
4055
- body: await parseErrorBody(output.body, context)
4056
- };
4057
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4058
- switch (errorCode) {
4059
- case "ResourceNotFoundException":
4060
- case "com.amazonaws.mgn#ResourceNotFoundException":
4061
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4062
- case "UninitializedAccountException":
4063
- case "com.amazonaws.mgn#UninitializedAccountException":
4064
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4065
- case "ValidationException":
4066
- case "com.amazonaws.mgn#ValidationException":
4067
- throw await de_ValidationExceptionRes(parsedOutput, context);
4068
- default:
4069
- const parsedBody = parsedOutput.body;
4070
- return throwDefaultError({
4071
- output,
4072
- parsedBody,
4073
- errorCode
4074
- });
4075
- }
4076
- }, "de_RemoveTemplateActionCommandError");
4077
2901
  var de_ResumeReplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
4078
2902
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4079
- return de_ResumeReplicationCommandError(output, context);
2903
+ return de_CommandError(output, context);
4080
2904
  }
4081
2905
  const contents = (0, import_smithy_client.map)({
4082
2906
  $metadata: deserializeMetadata(output)
@@ -4101,40 +2925,9 @@ var de_ResumeReplicationCommand = /* @__PURE__ */ __name(async (output, context)
4101
2925
  Object.assign(contents, doc);
4102
2926
  return contents;
4103
2927
  }, "de_ResumeReplicationCommand");
4104
- var de_ResumeReplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4105
- const parsedOutput = {
4106
- ...output,
4107
- body: await parseErrorBody(output.body, context)
4108
- };
4109
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4110
- switch (errorCode) {
4111
- case "ConflictException":
4112
- case "com.amazonaws.mgn#ConflictException":
4113
- throw await de_ConflictExceptionRes(parsedOutput, context);
4114
- case "ResourceNotFoundException":
4115
- case "com.amazonaws.mgn#ResourceNotFoundException":
4116
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4117
- case "ServiceQuotaExceededException":
4118
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4119
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4120
- case "UninitializedAccountException":
4121
- case "com.amazonaws.mgn#UninitializedAccountException":
4122
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4123
- case "ValidationException":
4124
- case "com.amazonaws.mgn#ValidationException":
4125
- throw await de_ValidationExceptionRes(parsedOutput, context);
4126
- default:
4127
- const parsedBody = parsedOutput.body;
4128
- return throwDefaultError({
4129
- output,
4130
- parsedBody,
4131
- errorCode
4132
- });
4133
- }
4134
- }, "de_ResumeReplicationCommandError");
4135
2928
  var de_RetryDataReplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
4136
2929
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4137
- return de_RetryDataReplicationCommandError(output, context);
2930
+ return de_CommandError(output, context);
4138
2931
  }
4139
2932
  const contents = (0, import_smithy_client.map)({
4140
2933
  $metadata: deserializeMetadata(output)
@@ -4156,76 +2949,26 @@ var de_RetryDataReplicationCommand = /* @__PURE__ */ __name(async (output, conte
4156
2949
  userProvidedID: import_smithy_client.expectString,
4157
2950
  vcenterClientID: import_smithy_client.expectString
4158
2951
  });
4159
- Object.assign(contents, doc);
4160
- return contents;
4161
- }, "de_RetryDataReplicationCommand");
4162
- var de_RetryDataReplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4163
- const parsedOutput = {
4164
- ...output,
4165
- body: await parseErrorBody(output.body, context)
4166
- };
4167
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4168
- switch (errorCode) {
4169
- case "ResourceNotFoundException":
4170
- case "com.amazonaws.mgn#ResourceNotFoundException":
4171
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4172
- case "UninitializedAccountException":
4173
- case "com.amazonaws.mgn#UninitializedAccountException":
4174
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4175
- case "ValidationException":
4176
- case "com.amazonaws.mgn#ValidationException":
4177
- throw await de_ValidationExceptionRes(parsedOutput, context);
4178
- default:
4179
- const parsedBody = parsedOutput.body;
4180
- return throwDefaultError({
4181
- output,
4182
- parsedBody,
4183
- errorCode
4184
- });
4185
- }
4186
- }, "de_RetryDataReplicationCommandError");
4187
- var de_StartCutoverCommand = /* @__PURE__ */ __name(async (output, context) => {
4188
- if (output.statusCode !== 202 && output.statusCode >= 300) {
4189
- return de_StartCutoverCommandError(output, context);
4190
- }
4191
- const contents = (0, import_smithy_client.map)({
4192
- $metadata: deserializeMetadata(output)
4193
- });
4194
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
4195
- const doc = (0, import_smithy_client.take)(data, {
4196
- job: import_smithy_client._json
4197
- });
4198
- Object.assign(contents, doc);
4199
- return contents;
4200
- }, "de_StartCutoverCommand");
4201
- var de_StartCutoverCommandError = /* @__PURE__ */ __name(async (output, context) => {
4202
- const parsedOutput = {
4203
- ...output,
4204
- body: await parseErrorBody(output.body, context)
4205
- };
4206
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4207
- switch (errorCode) {
4208
- case "ConflictException":
4209
- case "com.amazonaws.mgn#ConflictException":
4210
- throw await de_ConflictExceptionRes(parsedOutput, context);
4211
- case "UninitializedAccountException":
4212
- case "com.amazonaws.mgn#UninitializedAccountException":
4213
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4214
- case "ValidationException":
4215
- case "com.amazonaws.mgn#ValidationException":
4216
- throw await de_ValidationExceptionRes(parsedOutput, context);
4217
- default:
4218
- const parsedBody = parsedOutput.body;
4219
- return throwDefaultError({
4220
- output,
4221
- parsedBody,
4222
- errorCode
4223
- });
2952
+ Object.assign(contents, doc);
2953
+ return contents;
2954
+ }, "de_RetryDataReplicationCommand");
2955
+ var de_StartCutoverCommand = /* @__PURE__ */ __name(async (output, context) => {
2956
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
2957
+ return de_CommandError(output, context);
4224
2958
  }
4225
- }, "de_StartCutoverCommandError");
2959
+ const contents = (0, import_smithy_client.map)({
2960
+ $metadata: deserializeMetadata(output)
2961
+ });
2962
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
2963
+ const doc = (0, import_smithy_client.take)(data, {
2964
+ job: import_smithy_client._json
2965
+ });
2966
+ Object.assign(contents, doc);
2967
+ return contents;
2968
+ }, "de_StartCutoverCommand");
4226
2969
  var de_StartExportCommand = /* @__PURE__ */ __name(async (output, context) => {
4227
2970
  if (output.statusCode !== 202 && output.statusCode >= 300) {
4228
- return de_StartExportCommandError(output, context);
2971
+ return de_CommandError(output, context);
4229
2972
  }
4230
2973
  const contents = (0, import_smithy_client.map)({
4231
2974
  $metadata: deserializeMetadata(output)
@@ -4237,34 +2980,9 @@ var de_StartExportCommand = /* @__PURE__ */ __name(async (output, context) => {
4237
2980
  Object.assign(contents, doc);
4238
2981
  return contents;
4239
2982
  }, "de_StartExportCommand");
4240
- var de_StartExportCommandError = /* @__PURE__ */ __name(async (output, context) => {
4241
- const parsedOutput = {
4242
- ...output,
4243
- body: await parseErrorBody(output.body, context)
4244
- };
4245
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4246
- switch (errorCode) {
4247
- case "ServiceQuotaExceededException":
4248
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4249
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4250
- case "UninitializedAccountException":
4251
- case "com.amazonaws.mgn#UninitializedAccountException":
4252
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4253
- case "ValidationException":
4254
- case "com.amazonaws.mgn#ValidationException":
4255
- throw await de_ValidationExceptionRes(parsedOutput, context);
4256
- default:
4257
- const parsedBody = parsedOutput.body;
4258
- return throwDefaultError({
4259
- output,
4260
- parsedBody,
4261
- errorCode
4262
- });
4263
- }
4264
- }, "de_StartExportCommandError");
4265
2983
  var de_StartImportCommand = /* @__PURE__ */ __name(async (output, context) => {
4266
2984
  if (output.statusCode !== 202 && output.statusCode >= 300) {
4267
- return de_StartImportCommandError(output, context);
2985
+ return de_CommandError(output, context);
4268
2986
  }
4269
2987
  const contents = (0, import_smithy_client.map)({
4270
2988
  $metadata: deserializeMetadata(output)
@@ -4276,40 +2994,9 @@ var de_StartImportCommand = /* @__PURE__ */ __name(async (output, context) => {
4276
2994
  Object.assign(contents, doc);
4277
2995
  return contents;
4278
2996
  }, "de_StartImportCommand");
4279
- var de_StartImportCommandError = /* @__PURE__ */ __name(async (output, context) => {
4280
- const parsedOutput = {
4281
- ...output,
4282
- body: await parseErrorBody(output.body, context)
4283
- };
4284
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4285
- switch (errorCode) {
4286
- case "ConflictException":
4287
- case "com.amazonaws.mgn#ConflictException":
4288
- throw await de_ConflictExceptionRes(parsedOutput, context);
4289
- case "ResourceNotFoundException":
4290
- case "com.amazonaws.mgn#ResourceNotFoundException":
4291
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4292
- case "ServiceQuotaExceededException":
4293
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4294
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4295
- case "UninitializedAccountException":
4296
- case "com.amazonaws.mgn#UninitializedAccountException":
4297
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4298
- case "ValidationException":
4299
- case "com.amazonaws.mgn#ValidationException":
4300
- throw await de_ValidationExceptionRes(parsedOutput, context);
4301
- default:
4302
- const parsedBody = parsedOutput.body;
4303
- return throwDefaultError({
4304
- output,
4305
- parsedBody,
4306
- errorCode
4307
- });
4308
- }
4309
- }, "de_StartImportCommandError");
4310
2997
  var de_StartReplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
4311
2998
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4312
- return de_StartReplicationCommandError(output, context);
2999
+ return de_CommandError(output, context);
4313
3000
  }
4314
3001
  const contents = (0, import_smithy_client.map)({
4315
3002
  $metadata: deserializeMetadata(output)
@@ -4334,40 +3021,9 @@ var de_StartReplicationCommand = /* @__PURE__ */ __name(async (output, context)
4334
3021
  Object.assign(contents, doc);
4335
3022
  return contents;
4336
3023
  }, "de_StartReplicationCommand");
4337
- var de_StartReplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4338
- const parsedOutput = {
4339
- ...output,
4340
- body: await parseErrorBody(output.body, context)
4341
- };
4342
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4343
- switch (errorCode) {
4344
- case "ConflictException":
4345
- case "com.amazonaws.mgn#ConflictException":
4346
- throw await de_ConflictExceptionRes(parsedOutput, context);
4347
- case "ResourceNotFoundException":
4348
- case "com.amazonaws.mgn#ResourceNotFoundException":
4349
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4350
- case "ServiceQuotaExceededException":
4351
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4352
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4353
- case "UninitializedAccountException":
4354
- case "com.amazonaws.mgn#UninitializedAccountException":
4355
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4356
- case "ValidationException":
4357
- case "com.amazonaws.mgn#ValidationException":
4358
- throw await de_ValidationExceptionRes(parsedOutput, context);
4359
- default:
4360
- const parsedBody = parsedOutput.body;
4361
- return throwDefaultError({
4362
- output,
4363
- parsedBody,
4364
- errorCode
4365
- });
4366
- }
4367
- }, "de_StartReplicationCommandError");
4368
3024
  var de_StartTestCommand = /* @__PURE__ */ __name(async (output, context) => {
4369
3025
  if (output.statusCode !== 202 && output.statusCode >= 300) {
4370
- return de_StartTestCommandError(output, context);
3026
+ return de_CommandError(output, context);
4371
3027
  }
4372
3028
  const contents = (0, import_smithy_client.map)({
4373
3029
  $metadata: deserializeMetadata(output)
@@ -4379,34 +3035,9 @@ var de_StartTestCommand = /* @__PURE__ */ __name(async (output, context) => {
4379
3035
  Object.assign(contents, doc);
4380
3036
  return contents;
4381
3037
  }, "de_StartTestCommand");
4382
- var de_StartTestCommandError = /* @__PURE__ */ __name(async (output, context) => {
4383
- const parsedOutput = {
4384
- ...output,
4385
- body: await parseErrorBody(output.body, context)
4386
- };
4387
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4388
- switch (errorCode) {
4389
- case "ConflictException":
4390
- case "com.amazonaws.mgn#ConflictException":
4391
- throw await de_ConflictExceptionRes(parsedOutput, context);
4392
- case "UninitializedAccountException":
4393
- case "com.amazonaws.mgn#UninitializedAccountException":
4394
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4395
- case "ValidationException":
4396
- case "com.amazonaws.mgn#ValidationException":
4397
- throw await de_ValidationExceptionRes(parsedOutput, context);
4398
- default:
4399
- const parsedBody = parsedOutput.body;
4400
- return throwDefaultError({
4401
- output,
4402
- parsedBody,
4403
- errorCode
4404
- });
4405
- }
4406
- }, "de_StartTestCommandError");
4407
3038
  var de_StopReplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
4408
3039
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4409
- return de_StopReplicationCommandError(output, context);
3040
+ return de_CommandError(output, context);
4410
3041
  }
4411
3042
  const contents = (0, import_smithy_client.map)({
4412
3043
  $metadata: deserializeMetadata(output)
@@ -4431,40 +3062,9 @@ var de_StopReplicationCommand = /* @__PURE__ */ __name(async (output, context) =
4431
3062
  Object.assign(contents, doc);
4432
3063
  return contents;
4433
3064
  }, "de_StopReplicationCommand");
4434
- var de_StopReplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4435
- const parsedOutput = {
4436
- ...output,
4437
- body: await parseErrorBody(output.body, context)
4438
- };
4439
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4440
- switch (errorCode) {
4441
- case "ConflictException":
4442
- case "com.amazonaws.mgn#ConflictException":
4443
- throw await de_ConflictExceptionRes(parsedOutput, context);
4444
- case "ResourceNotFoundException":
4445
- case "com.amazonaws.mgn#ResourceNotFoundException":
4446
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4447
- case "ServiceQuotaExceededException":
4448
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4449
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4450
- case "UninitializedAccountException":
4451
- case "com.amazonaws.mgn#UninitializedAccountException":
4452
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4453
- case "ValidationException":
4454
- case "com.amazonaws.mgn#ValidationException":
4455
- throw await de_ValidationExceptionRes(parsedOutput, context);
4456
- default:
4457
- const parsedBody = parsedOutput.body;
4458
- return throwDefaultError({
4459
- output,
4460
- parsedBody,
4461
- errorCode
4462
- });
4463
- }
4464
- }, "de_StopReplicationCommandError");
4465
3065
  var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
4466
3066
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4467
- return de_TagResourceCommandError(output, context);
3067
+ return de_CommandError(output, context);
4468
3068
  }
4469
3069
  const contents = (0, import_smithy_client.map)({
4470
3070
  $metadata: deserializeMetadata(output)
@@ -4472,40 +3072,9 @@ var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
4472
3072
  await (0, import_smithy_client.collectBody)(output.body, context);
4473
3073
  return contents;
4474
3074
  }, "de_TagResourceCommand");
4475
- var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
4476
- const parsedOutput = {
4477
- ...output,
4478
- body: await parseErrorBody(output.body, context)
4479
- };
4480
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4481
- switch (errorCode) {
4482
- case "AccessDeniedException":
4483
- case "com.amazonaws.mgn#AccessDeniedException":
4484
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4485
- case "InternalServerException":
4486
- case "com.amazonaws.mgn#InternalServerException":
4487
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4488
- case "ResourceNotFoundException":
4489
- case "com.amazonaws.mgn#ResourceNotFoundException":
4490
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4491
- case "ThrottlingException":
4492
- case "com.amazonaws.mgn#ThrottlingException":
4493
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4494
- case "ValidationException":
4495
- case "com.amazonaws.mgn#ValidationException":
4496
- throw await de_ValidationExceptionRes(parsedOutput, context);
4497
- default:
4498
- const parsedBody = parsedOutput.body;
4499
- return throwDefaultError({
4500
- output,
4501
- parsedBody,
4502
- errorCode
4503
- });
4504
- }
4505
- }, "de_TagResourceCommandError");
4506
3075
  var de_TerminateTargetInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
4507
3076
  if (output.statusCode !== 202 && output.statusCode >= 300) {
4508
- return de_TerminateTargetInstancesCommandError(output, context);
3077
+ return de_CommandError(output, context);
4509
3078
  }
4510
3079
  const contents = (0, import_smithy_client.map)({
4511
3080
  $metadata: deserializeMetadata(output)
@@ -4517,34 +3086,9 @@ var de_TerminateTargetInstancesCommand = /* @__PURE__ */ __name(async (output, c
4517
3086
  Object.assign(contents, doc);
4518
3087
  return contents;
4519
3088
  }, "de_TerminateTargetInstancesCommand");
4520
- var de_TerminateTargetInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
4521
- const parsedOutput = {
4522
- ...output,
4523
- body: await parseErrorBody(output.body, context)
4524
- };
4525
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4526
- switch (errorCode) {
4527
- case "ConflictException":
4528
- case "com.amazonaws.mgn#ConflictException":
4529
- throw await de_ConflictExceptionRes(parsedOutput, context);
4530
- case "UninitializedAccountException":
4531
- case "com.amazonaws.mgn#UninitializedAccountException":
4532
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4533
- case "ValidationException":
4534
- case "com.amazonaws.mgn#ValidationException":
4535
- throw await de_ValidationExceptionRes(parsedOutput, context);
4536
- default:
4537
- const parsedBody = parsedOutput.body;
4538
- return throwDefaultError({
4539
- output,
4540
- parsedBody,
4541
- errorCode
4542
- });
4543
- }
4544
- }, "de_TerminateTargetInstancesCommandError");
4545
3089
  var de_UnarchiveApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
4546
3090
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4547
- return de_UnarchiveApplicationCommandError(output, context);
3091
+ return de_CommandError(output, context);
4548
3092
  }
4549
3093
  const contents = (0, import_smithy_client.map)({
4550
3094
  $metadata: deserializeMetadata(output)
@@ -4565,34 +3109,9 @@ var de_UnarchiveApplicationCommand = /* @__PURE__ */ __name(async (output, conte
4565
3109
  Object.assign(contents, doc);
4566
3110
  return contents;
4567
3111
  }, "de_UnarchiveApplicationCommand");
4568
- var de_UnarchiveApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4569
- const parsedOutput = {
4570
- ...output,
4571
- body: await parseErrorBody(output.body, context)
4572
- };
4573
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4574
- switch (errorCode) {
4575
- case "ResourceNotFoundException":
4576
- case "com.amazonaws.mgn#ResourceNotFoundException":
4577
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4578
- case "ServiceQuotaExceededException":
4579
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4580
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4581
- case "UninitializedAccountException":
4582
- case "com.amazonaws.mgn#UninitializedAccountException":
4583
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4584
- default:
4585
- const parsedBody = parsedOutput.body;
4586
- return throwDefaultError({
4587
- output,
4588
- parsedBody,
4589
- errorCode
4590
- });
4591
- }
4592
- }, "de_UnarchiveApplicationCommandError");
4593
3112
  var de_UnarchiveWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
4594
3113
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4595
- return de_UnarchiveWaveCommandError(output, context);
3114
+ return de_CommandError(output, context);
4596
3115
  }
4597
3116
  const contents = (0, import_smithy_client.map)({
4598
3117
  $metadata: deserializeMetadata(output)
@@ -4602,44 +3121,19 @@ var de_UnarchiveWaveCommand = /* @__PURE__ */ __name(async (output, context) =>
4602
3121
  arn: import_smithy_client.expectString,
4603
3122
  creationDateTime: import_smithy_client.expectString,
4604
3123
  description: import_smithy_client.expectString,
4605
- isArchived: import_smithy_client.expectBoolean,
4606
- lastModifiedDateTime: import_smithy_client.expectString,
4607
- name: import_smithy_client.expectString,
4608
- tags: import_smithy_client._json,
4609
- waveAggregatedStatus: import_smithy_client._json,
4610
- waveID: import_smithy_client.expectString
4611
- });
4612
- Object.assign(contents, doc);
4613
- return contents;
4614
- }, "de_UnarchiveWaveCommand");
4615
- var de_UnarchiveWaveCommandError = /* @__PURE__ */ __name(async (output, context) => {
4616
- const parsedOutput = {
4617
- ...output,
4618
- body: await parseErrorBody(output.body, context)
4619
- };
4620
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4621
- switch (errorCode) {
4622
- case "ResourceNotFoundException":
4623
- case "com.amazonaws.mgn#ResourceNotFoundException":
4624
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4625
- case "ServiceQuotaExceededException":
4626
- case "com.amazonaws.mgn#ServiceQuotaExceededException":
4627
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
4628
- case "UninitializedAccountException":
4629
- case "com.amazonaws.mgn#UninitializedAccountException":
4630
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4631
- default:
4632
- const parsedBody = parsedOutput.body;
4633
- return throwDefaultError({
4634
- output,
4635
- parsedBody,
4636
- errorCode
4637
- });
4638
- }
4639
- }, "de_UnarchiveWaveCommandError");
3124
+ isArchived: import_smithy_client.expectBoolean,
3125
+ lastModifiedDateTime: import_smithy_client.expectString,
3126
+ name: import_smithy_client.expectString,
3127
+ tags: import_smithy_client._json,
3128
+ waveAggregatedStatus: import_smithy_client._json,
3129
+ waveID: import_smithy_client.expectString
3130
+ });
3131
+ Object.assign(contents, doc);
3132
+ return contents;
3133
+ }, "de_UnarchiveWaveCommand");
4640
3134
  var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
4641
3135
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4642
- return de_UntagResourceCommandError(output, context);
3136
+ return de_CommandError(output, context);
4643
3137
  }
4644
3138
  const contents = (0, import_smithy_client.map)({
4645
3139
  $metadata: deserializeMetadata(output)
@@ -4647,40 +3141,9 @@ var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) =>
4647
3141
  await (0, import_smithy_client.collectBody)(output.body, context);
4648
3142
  return contents;
4649
3143
  }, "de_UntagResourceCommand");
4650
- var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
4651
- const parsedOutput = {
4652
- ...output,
4653
- body: await parseErrorBody(output.body, context)
4654
- };
4655
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4656
- switch (errorCode) {
4657
- case "AccessDeniedException":
4658
- case "com.amazonaws.mgn#AccessDeniedException":
4659
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4660
- case "InternalServerException":
4661
- case "com.amazonaws.mgn#InternalServerException":
4662
- throw await de_InternalServerExceptionRes(parsedOutput, context);
4663
- case "ResourceNotFoundException":
4664
- case "com.amazonaws.mgn#ResourceNotFoundException":
4665
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4666
- case "ThrottlingException":
4667
- case "com.amazonaws.mgn#ThrottlingException":
4668
- throw await de_ThrottlingExceptionRes(parsedOutput, context);
4669
- case "ValidationException":
4670
- case "com.amazonaws.mgn#ValidationException":
4671
- throw await de_ValidationExceptionRes(parsedOutput, context);
4672
- default:
4673
- const parsedBody = parsedOutput.body;
4674
- return throwDefaultError({
4675
- output,
4676
- parsedBody,
4677
- errorCode
4678
- });
4679
- }
4680
- }, "de_UntagResourceCommandError");
4681
3144
  var de_UpdateApplicationCommand = /* @__PURE__ */ __name(async (output, context) => {
4682
3145
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4683
- return de_UpdateApplicationCommandError(output, context);
3146
+ return de_CommandError(output, context);
4684
3147
  }
4685
3148
  const contents = (0, import_smithy_client.map)({
4686
3149
  $metadata: deserializeMetadata(output)
@@ -4701,34 +3164,9 @@ var de_UpdateApplicationCommand = /* @__PURE__ */ __name(async (output, context)
4701
3164
  Object.assign(contents, doc);
4702
3165
  return contents;
4703
3166
  }, "de_UpdateApplicationCommand");
4704
- var de_UpdateApplicationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4705
- const parsedOutput = {
4706
- ...output,
4707
- body: await parseErrorBody(output.body, context)
4708
- };
4709
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4710
- switch (errorCode) {
4711
- case "ConflictException":
4712
- case "com.amazonaws.mgn#ConflictException":
4713
- throw await de_ConflictExceptionRes(parsedOutput, context);
4714
- case "ResourceNotFoundException":
4715
- case "com.amazonaws.mgn#ResourceNotFoundException":
4716
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4717
- case "UninitializedAccountException":
4718
- case "com.amazonaws.mgn#UninitializedAccountException":
4719
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4720
- default:
4721
- const parsedBody = parsedOutput.body;
4722
- return throwDefaultError({
4723
- output,
4724
- parsedBody,
4725
- errorCode
4726
- });
4727
- }
4728
- }, "de_UpdateApplicationCommandError");
4729
3167
  var de_UpdateConnectorCommand = /* @__PURE__ */ __name(async (output, context) => {
4730
3168
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4731
- return de_UpdateConnectorCommandError(output, context);
3169
+ return de_CommandError(output, context);
4732
3170
  }
4733
3171
  const contents = (0, import_smithy_client.map)({
4734
3172
  $metadata: deserializeMetadata(output)
@@ -4745,34 +3183,9 @@ var de_UpdateConnectorCommand = /* @__PURE__ */ __name(async (output, context) =
4745
3183
  Object.assign(contents, doc);
4746
3184
  return contents;
4747
3185
  }, "de_UpdateConnectorCommand");
4748
- var de_UpdateConnectorCommandError = /* @__PURE__ */ __name(async (output, context) => {
4749
- const parsedOutput = {
4750
- ...output,
4751
- body: await parseErrorBody(output.body, context)
4752
- };
4753
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4754
- switch (errorCode) {
4755
- case "ResourceNotFoundException":
4756
- case "com.amazonaws.mgn#ResourceNotFoundException":
4757
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4758
- case "UninitializedAccountException":
4759
- case "com.amazonaws.mgn#UninitializedAccountException":
4760
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4761
- case "ValidationException":
4762
- case "com.amazonaws.mgn#ValidationException":
4763
- throw await de_ValidationExceptionRes(parsedOutput, context);
4764
- default:
4765
- const parsedBody = parsedOutput.body;
4766
- return throwDefaultError({
4767
- output,
4768
- parsedBody,
4769
- errorCode
4770
- });
4771
- }
4772
- }, "de_UpdateConnectorCommandError");
4773
3186
  var de_UpdateLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
4774
3187
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4775
- return de_UpdateLaunchConfigurationCommandError(output, context);
3188
+ return de_CommandError(output, context);
4776
3189
  }
4777
3190
  const contents = (0, import_smithy_client.map)({
4778
3191
  $metadata: deserializeMetadata(output)
@@ -4795,37 +3208,9 @@ var de_UpdateLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output,
4795
3208
  Object.assign(contents, doc);
4796
3209
  return contents;
4797
3210
  }, "de_UpdateLaunchConfigurationCommand");
4798
- var de_UpdateLaunchConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4799
- const parsedOutput = {
4800
- ...output,
4801
- body: await parseErrorBody(output.body, context)
4802
- };
4803
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4804
- switch (errorCode) {
4805
- case "ConflictException":
4806
- case "com.amazonaws.mgn#ConflictException":
4807
- throw await de_ConflictExceptionRes(parsedOutput, context);
4808
- case "ResourceNotFoundException":
4809
- case "com.amazonaws.mgn#ResourceNotFoundException":
4810
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4811
- case "UninitializedAccountException":
4812
- case "com.amazonaws.mgn#UninitializedAccountException":
4813
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4814
- case "ValidationException":
4815
- case "com.amazonaws.mgn#ValidationException":
4816
- throw await de_ValidationExceptionRes(parsedOutput, context);
4817
- default:
4818
- const parsedBody = parsedOutput.body;
4819
- return throwDefaultError({
4820
- output,
4821
- parsedBody,
4822
- errorCode
4823
- });
4824
- }
4825
- }, "de_UpdateLaunchConfigurationCommandError");
4826
3211
  var de_UpdateLaunchConfigurationTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
4827
3212
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4828
- return de_UpdateLaunchConfigurationTemplateCommandError(output, context);
3213
+ return de_CommandError(output, context);
4829
3214
  }
4830
3215
  const contents = (0, import_smithy_client.map)({
4831
3216
  $metadata: deserializeMetadata(output)
@@ -4853,37 +3238,9 @@ var de_UpdateLaunchConfigurationTemplateCommand = /* @__PURE__ */ __name(async (
4853
3238
  Object.assign(contents, doc);
4854
3239
  return contents;
4855
3240
  }, "de_UpdateLaunchConfigurationTemplateCommand");
4856
- var de_UpdateLaunchConfigurationTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
4857
- const parsedOutput = {
4858
- ...output,
4859
- body: await parseErrorBody(output.body, context)
4860
- };
4861
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4862
- switch (errorCode) {
4863
- case "AccessDeniedException":
4864
- case "com.amazonaws.mgn#AccessDeniedException":
4865
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4866
- case "ResourceNotFoundException":
4867
- case "com.amazonaws.mgn#ResourceNotFoundException":
4868
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4869
- case "UninitializedAccountException":
4870
- case "com.amazonaws.mgn#UninitializedAccountException":
4871
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4872
- case "ValidationException":
4873
- case "com.amazonaws.mgn#ValidationException":
4874
- throw await de_ValidationExceptionRes(parsedOutput, context);
4875
- default:
4876
- const parsedBody = parsedOutput.body;
4877
- return throwDefaultError({
4878
- output,
4879
- parsedBody,
4880
- errorCode
4881
- });
4882
- }
4883
- }, "de_UpdateLaunchConfigurationTemplateCommandError");
4884
3241
  var de_UpdateReplicationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
4885
3242
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4886
- return de_UpdateReplicationConfigurationCommandError(output, context);
3243
+ return de_CommandError(output, context);
4887
3244
  }
4888
3245
  const contents = (0, import_smithy_client.map)({
4889
3246
  $metadata: deserializeMetadata(output)
@@ -4910,40 +3267,9 @@ var de_UpdateReplicationConfigurationCommand = /* @__PURE__ */ __name(async (out
4910
3267
  Object.assign(contents, doc);
4911
3268
  return contents;
4912
3269
  }, "de_UpdateReplicationConfigurationCommand");
4913
- var de_UpdateReplicationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
4914
- const parsedOutput = {
4915
- ...output,
4916
- body: await parseErrorBody(output.body, context)
4917
- };
4918
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4919
- switch (errorCode) {
4920
- case "AccessDeniedException":
4921
- case "com.amazonaws.mgn#AccessDeniedException":
4922
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4923
- case "ConflictException":
4924
- case "com.amazonaws.mgn#ConflictException":
4925
- throw await de_ConflictExceptionRes(parsedOutput, context);
4926
- case "ResourceNotFoundException":
4927
- case "com.amazonaws.mgn#ResourceNotFoundException":
4928
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4929
- case "UninitializedAccountException":
4930
- case "com.amazonaws.mgn#UninitializedAccountException":
4931
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4932
- case "ValidationException":
4933
- case "com.amazonaws.mgn#ValidationException":
4934
- throw await de_ValidationExceptionRes(parsedOutput, context);
4935
- default:
4936
- const parsedBody = parsedOutput.body;
4937
- return throwDefaultError({
4938
- output,
4939
- parsedBody,
4940
- errorCode
4941
- });
4942
- }
4943
- }, "de_UpdateReplicationConfigurationCommandError");
4944
3270
  var de_UpdateReplicationConfigurationTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
4945
3271
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4946
- return de_UpdateReplicationConfigurationTemplateCommandError(output, context);
3272
+ return de_CommandError(output, context);
4947
3273
  }
4948
3274
  const contents = (0, import_smithy_client.map)({
4949
3275
  $metadata: deserializeMetadata(output)
@@ -4970,37 +3296,9 @@ var de_UpdateReplicationConfigurationTemplateCommand = /* @__PURE__ */ __name(as
4970
3296
  Object.assign(contents, doc);
4971
3297
  return contents;
4972
3298
  }, "de_UpdateReplicationConfigurationTemplateCommand");
4973
- var de_UpdateReplicationConfigurationTemplateCommandError = /* @__PURE__ */ __name(async (output, context) => {
4974
- const parsedOutput = {
4975
- ...output,
4976
- body: await parseErrorBody(output.body, context)
4977
- };
4978
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4979
- switch (errorCode) {
4980
- case "AccessDeniedException":
4981
- case "com.amazonaws.mgn#AccessDeniedException":
4982
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4983
- case "ResourceNotFoundException":
4984
- case "com.amazonaws.mgn#ResourceNotFoundException":
4985
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4986
- case "UninitializedAccountException":
4987
- case "com.amazonaws.mgn#UninitializedAccountException":
4988
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
4989
- case "ValidationException":
4990
- case "com.amazonaws.mgn#ValidationException":
4991
- throw await de_ValidationExceptionRes(parsedOutput, context);
4992
- default:
4993
- const parsedBody = parsedOutput.body;
4994
- return throwDefaultError({
4995
- output,
4996
- parsedBody,
4997
- errorCode
4998
- });
4999
- }
5000
- }, "de_UpdateReplicationConfigurationTemplateCommandError");
5001
3299
  var de_UpdateSourceServerCommand = /* @__PURE__ */ __name(async (output, context) => {
5002
3300
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5003
- return de_UpdateSourceServerCommandError(output, context);
3301
+ return de_CommandError(output, context);
5004
3302
  }
5005
3303
  const contents = (0, import_smithy_client.map)({
5006
3304
  $metadata: deserializeMetadata(output)
@@ -5025,34 +3323,9 @@ var de_UpdateSourceServerCommand = /* @__PURE__ */ __name(async (output, context
5025
3323
  Object.assign(contents, doc);
5026
3324
  return contents;
5027
3325
  }, "de_UpdateSourceServerCommand");
5028
- var de_UpdateSourceServerCommandError = /* @__PURE__ */ __name(async (output, context) => {
5029
- const parsedOutput = {
5030
- ...output,
5031
- body: await parseErrorBody(output.body, context)
5032
- };
5033
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5034
- switch (errorCode) {
5035
- case "ConflictException":
5036
- case "com.amazonaws.mgn#ConflictException":
5037
- throw await de_ConflictExceptionRes(parsedOutput, context);
5038
- case "ResourceNotFoundException":
5039
- case "com.amazonaws.mgn#ResourceNotFoundException":
5040
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5041
- case "UninitializedAccountException":
5042
- case "com.amazonaws.mgn#UninitializedAccountException":
5043
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
5044
- default:
5045
- const parsedBody = parsedOutput.body;
5046
- return throwDefaultError({
5047
- output,
5048
- parsedBody,
5049
- errorCode
5050
- });
5051
- }
5052
- }, "de_UpdateSourceServerCommandError");
5053
3326
  var de_UpdateSourceServerReplicationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
5054
3327
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5055
- return de_UpdateSourceServerReplicationTypeCommandError(output, context);
3328
+ return de_CommandError(output, context);
5056
3329
  }
5057
3330
  const contents = (0, import_smithy_client.map)({
5058
3331
  $metadata: deserializeMetadata(output)
@@ -5077,37 +3350,9 @@ var de_UpdateSourceServerReplicationTypeCommand = /* @__PURE__ */ __name(async (
5077
3350
  Object.assign(contents, doc);
5078
3351
  return contents;
5079
3352
  }, "de_UpdateSourceServerReplicationTypeCommand");
5080
- var de_UpdateSourceServerReplicationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
5081
- const parsedOutput = {
5082
- ...output,
5083
- body: await parseErrorBody(output.body, context)
5084
- };
5085
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
5086
- switch (errorCode) {
5087
- case "ConflictException":
5088
- case "com.amazonaws.mgn#ConflictException":
5089
- throw await de_ConflictExceptionRes(parsedOutput, context);
5090
- case "ResourceNotFoundException":
5091
- case "com.amazonaws.mgn#ResourceNotFoundException":
5092
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
5093
- case "UninitializedAccountException":
5094
- case "com.amazonaws.mgn#UninitializedAccountException":
5095
- throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
5096
- case "ValidationException":
5097
- case "com.amazonaws.mgn#ValidationException":
5098
- throw await de_ValidationExceptionRes(parsedOutput, context);
5099
- default:
5100
- const parsedBody = parsedOutput.body;
5101
- return throwDefaultError({
5102
- output,
5103
- parsedBody,
5104
- errorCode
5105
- });
5106
- }
5107
- }, "de_UpdateSourceServerReplicationTypeCommandError");
5108
3353
  var de_UpdateWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
5109
3354
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5110
- return de_UpdateWaveCommandError(output, context);
3355
+ return de_CommandError(output, context);
5111
3356
  }
5112
3357
  const contents = (0, import_smithy_client.map)({
5113
3358
  $metadata: deserializeMetadata(output)
@@ -5127,7 +3372,7 @@ var de_UpdateWaveCommand = /* @__PURE__ */ __name(async (output, context) => {
5127
3372
  Object.assign(contents, doc);
5128
3373
  return contents;
5129
3374
  }, "de_UpdateWaveCommand");
5130
- var de_UpdateWaveCommandError = /* @__PURE__ */ __name(async (output, context) => {
3375
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
5131
3376
  const parsedOutput = {
5132
3377
  ...output,
5133
3378
  body: await parseErrorBody(output.body, context)
@@ -5140,9 +3385,24 @@ var de_UpdateWaveCommandError = /* @__PURE__ */ __name(async (output, context) =
5140
3385
  case "ResourceNotFoundException":
5141
3386
  case "com.amazonaws.mgn#ResourceNotFoundException":
5142
3387
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3388
+ case "ServiceQuotaExceededException":
3389
+ case "com.amazonaws.mgn#ServiceQuotaExceededException":
3390
+ throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
5143
3391
  case "UninitializedAccountException":
5144
3392
  case "com.amazonaws.mgn#UninitializedAccountException":
5145
3393
  throw await de_UninitializedAccountExceptionRes(parsedOutput, context);
3394
+ case "ValidationException":
3395
+ case "com.amazonaws.mgn#ValidationException":
3396
+ throw await de_ValidationExceptionRes(parsedOutput, context);
3397
+ case "AccessDeniedException":
3398
+ case "com.amazonaws.mgn#AccessDeniedException":
3399
+ throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3400
+ case "InternalServerException":
3401
+ case "com.amazonaws.mgn#InternalServerException":
3402
+ throw await de_InternalServerExceptionRes(parsedOutput, context);
3403
+ case "ThrottlingException":
3404
+ case "com.amazonaws.mgn#ThrottlingException":
3405
+ throw await de_ThrottlingExceptionRes(parsedOutput, context);
5146
3406
  default:
5147
3407
  const parsedBody = parsedOutput.body;
5148
3408
  return throwDefaultError({
@@ -5151,7 +3411,7 @@ var de_UpdateWaveCommandError = /* @__PURE__ */ __name(async (output, context) =
5151
3411
  errorCode
5152
3412
  });
5153
3413
  }
5154
- }, "de_UpdateWaveCommandError");
3414
+ }, "de_CommandError");
5155
3415
  var throwDefaultError = (0, import_smithy_client.withBaseException)(MgnServiceException);
5156
3416
  var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
5157
3417
  const contents = (0, import_smithy_client.map)({});