@aws-sdk/client-pcs 3.927.0 → 3.929.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (43) hide show
  1. package/dist-cjs/index.js +767 -907
  2. package/dist-cjs/runtimeConfig.shared.js +7 -0
  3. package/dist-es/PCSClient.js +2 -0
  4. package/dist-es/commands/CreateClusterCommand.js +3 -9
  5. package/dist-es/commands/CreateComputeNodeGroupCommand.js +3 -9
  6. package/dist-es/commands/CreateQueueCommand.js +3 -9
  7. package/dist-es/commands/DeleteClusterCommand.js +3 -9
  8. package/dist-es/commands/DeleteComputeNodeGroupCommand.js +3 -9
  9. package/dist-es/commands/DeleteQueueCommand.js +3 -9
  10. package/dist-es/commands/GetClusterCommand.js +3 -9
  11. package/dist-es/commands/GetComputeNodeGroupCommand.js +3 -9
  12. package/dist-es/commands/GetQueueCommand.js +3 -9
  13. package/dist-es/commands/ListClustersCommand.js +3 -9
  14. package/dist-es/commands/ListComputeNodeGroupsCommand.js +3 -9
  15. package/dist-es/commands/ListQueuesCommand.js +3 -9
  16. package/dist-es/commands/ListTagsForResourceCommand.js +3 -9
  17. package/dist-es/commands/RegisterComputeNodeGroupInstanceCommand.js +3 -10
  18. package/dist-es/commands/TagResourceCommand.js +3 -9
  19. package/dist-es/commands/UntagResourceCommand.js +3 -9
  20. package/dist-es/commands/UpdateClusterCommand.js +3 -9
  21. package/dist-es/commands/UpdateComputeNodeGroupCommand.js +3 -9
  22. package/dist-es/commands/UpdateQueueCommand.js +3 -9
  23. package/dist-es/models/models_0.js +0 -5
  24. package/dist-es/runtimeConfig.shared.js +7 -0
  25. package/dist-es/schemas/schemas_0.js +712 -0
  26. package/dist-types/PCSClient.d.ts +10 -1
  27. package/dist-types/models/models_0.d.ts +0 -4
  28. package/dist-types/runtimeConfig.browser.d.ts +1 -0
  29. package/dist-types/runtimeConfig.d.ts +1 -0
  30. package/dist-types/runtimeConfig.native.d.ts +1 -0
  31. package/dist-types/runtimeConfig.shared.d.ts +1 -0
  32. package/dist-types/schemas/schemas_0.d.ts +114 -0
  33. package/dist-types/ts3.4/PCSClient.d.ts +4 -0
  34. package/dist-types/ts3.4/models/models_0.d.ts +0 -3
  35. package/dist-types/ts3.4/runtimeConfig.browser.d.ts +4 -0
  36. package/dist-types/ts3.4/runtimeConfig.d.ts +4 -0
  37. package/dist-types/ts3.4/runtimeConfig.native.d.ts +4 -0
  38. package/dist-types/ts3.4/runtimeConfig.shared.d.ts +4 -0
  39. package/dist-types/ts3.4/schemas/schemas_0.d.ts +120 -0
  40. package/package.json +5 -6
  41. package/dist-es/protocols/Aws_json1_0.js +0 -752
  42. package/dist-types/protocols/Aws_json1_0.d.ts +0 -173
  43. package/dist-types/ts3.4/protocols/Aws_json1_0.d.ts +0 -233
package/dist-cjs/index.js CHANGED
@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
6
6
  var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
7
  var configResolver = require('@smithy/config-resolver');
8
8
  var core = require('@smithy/core');
9
+ var schema = require('@smithy/core/schema');
9
10
  var middlewareContentLength = require('@smithy/middleware-content-length');
10
11
  var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
12
  var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
15
  var runtimeConfig = require('./runtimeConfig');
15
16
  var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
17
  var protocolHttp = require('@smithy/protocol-http');
17
- var middlewareSerde = require('@smithy/middleware-serde');
18
- var core$1 = require('@aws-sdk/core');
19
- var uuid = require('@smithy/uuid');
20
18
 
21
19
  const resolveClientEndpointParameters = (options) => {
22
20
  return Object.assign(options, {
@@ -92,6 +90,7 @@ class PCSClient extends smithyClient.Client {
92
90
  const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
93
91
  const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
94
92
  this.config = _config_8;
93
+ this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
95
94
  this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
96
95
  this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
97
96
  this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class PCSClient extends smithyClient.Client {
111
110
  }
112
111
  }
113
112
 
114
- class PCSServiceException extends smithyClient.ServiceException {
113
+ let PCSServiceException$1 = class PCSServiceException extends smithyClient.ServiceException {
115
114
  constructor(options) {
116
115
  super(options);
117
116
  Object.setPrototypeOf(this, PCSServiceException.prototype);
118
117
  }
119
- }
118
+ };
120
119
 
121
- class AccessDeniedException extends PCSServiceException {
120
+ let AccessDeniedException$1 = class AccessDeniedException extends PCSServiceException$1 {
122
121
  name = "AccessDeniedException";
123
122
  $fault = "client";
124
123
  constructor(opts) {
@@ -129,12 +128,12 @@ class AccessDeniedException extends PCSServiceException {
129
128
  });
130
129
  Object.setPrototypeOf(this, AccessDeniedException.prototype);
131
130
  }
132
- }
131
+ };
133
132
  const AccountingMode = {
134
133
  NONE: "NONE",
135
134
  STANDARD: "STANDARD",
136
135
  };
137
- class ConflictException extends PCSServiceException {
136
+ let ConflictException$1 = class ConflictException extends PCSServiceException$1 {
138
137
  name = "ConflictException";
139
138
  $fault = "client";
140
139
  resourceId;
@@ -149,7 +148,7 @@ class ConflictException extends PCSServiceException {
149
148
  this.resourceId = opts.resourceId;
150
149
  this.resourceType = opts.resourceType;
151
150
  }
152
- }
151
+ };
153
152
  const PurchaseOption = {
154
153
  CAPACITY_BLOCK: "CAPACITY_BLOCK",
155
154
  ONDEMAND: "ONDEMAND",
@@ -172,7 +171,7 @@ const ComputeNodeGroupStatus = {
172
171
  UPDATE_FAILED: "UPDATE_FAILED",
173
172
  UPDATING: "UPDATING",
174
173
  };
175
- class InternalServerException extends PCSServiceException {
174
+ let InternalServerException$1 = class InternalServerException extends PCSServiceException$1 {
176
175
  name = "InternalServerException";
177
176
  $fault = "server";
178
177
  $retryable = {};
@@ -184,8 +183,8 @@ class InternalServerException extends PCSServiceException {
184
183
  });
185
184
  Object.setPrototypeOf(this, InternalServerException.prototype);
186
185
  }
187
- }
188
- class ResourceNotFoundException extends PCSServiceException {
186
+ };
187
+ let ResourceNotFoundException$1 = class ResourceNotFoundException extends PCSServiceException$1 {
189
188
  name = "ResourceNotFoundException";
190
189
  $fault = "client";
191
190
  resourceId;
@@ -200,8 +199,8 @@ class ResourceNotFoundException extends PCSServiceException {
200
199
  this.resourceId = opts.resourceId;
201
200
  this.resourceType = opts.resourceType;
202
201
  }
203
- }
204
- class ServiceQuotaExceededException extends PCSServiceException {
202
+ };
203
+ let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends PCSServiceException$1 {
205
204
  name = "ServiceQuotaExceededException";
206
205
  $fault = "client";
207
206
  serviceCode;
@@ -220,8 +219,8 @@ class ServiceQuotaExceededException extends PCSServiceException {
220
219
  this.resourceType = opts.resourceType;
221
220
  this.quotaCode = opts.quotaCode;
222
221
  }
223
- }
224
- class ThrottlingException extends PCSServiceException {
222
+ };
223
+ let ThrottlingException$1 = class ThrottlingException extends PCSServiceException$1 {
225
224
  name = "ThrottlingException";
226
225
  $fault = "client";
227
226
  $retryable = {};
@@ -235,14 +234,14 @@ class ThrottlingException extends PCSServiceException {
235
234
  Object.setPrototypeOf(this, ThrottlingException.prototype);
236
235
  this.retryAfterSeconds = opts.retryAfterSeconds;
237
236
  }
238
- }
237
+ };
239
238
  const ValidationExceptionReason = {
240
239
  CANNOT_PARSE: "cannotParse",
241
240
  FIELD_VALIDATION_FAILED: "fieldValidationFailed",
242
241
  OTHER: "other",
243
242
  UNKNOWN_OPERATION: "unknownOperation",
244
243
  };
245
- class ValidationException extends PCSServiceException {
244
+ let ValidationException$1 = class ValidationException extends PCSServiceException$1 {
246
245
  name = "ValidationException";
247
246
  $fault = "client";
248
247
  reason;
@@ -257,7 +256,7 @@ class ValidationException extends PCSServiceException {
257
256
  this.reason = opts.reason;
258
257
  this.fieldList = opts.fieldList;
259
258
  }
260
- }
259
+ };
261
260
  const NetworkType = {
262
261
  IPV4: "IPV4",
263
262
  IPV6: "IPV6",
@@ -296,768 +295,720 @@ const QueueStatus = {
296
295
  UPDATE_FAILED: "UPDATE_FAILED",
297
296
  UPDATING: "UPDATING",
298
297
  };
299
- const RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog = (obj) => ({
300
- ...obj,
301
- ...(obj.sharedSecret && { sharedSecret: smithyClient.SENSITIVE_STRING }),
302
- });
303
298
 
304
- const se_CreateClusterCommand = async (input, context) => {
305
- const headers = sharedHeaders("CreateCluster");
306
- let body;
307
- body = JSON.stringify(se_CreateClusterRequest(input));
308
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
309
- };
310
- const se_CreateComputeNodeGroupCommand = async (input, context) => {
311
- const headers = sharedHeaders("CreateComputeNodeGroup");
312
- let body;
313
- body = JSON.stringify(se_CreateComputeNodeGroupRequest(input));
314
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
315
- };
316
- const se_CreateQueueCommand = async (input, context) => {
317
- const headers = sharedHeaders("CreateQueue");
318
- let body;
319
- body = JSON.stringify(se_CreateQueueRequest(input));
320
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
321
- };
322
- const se_DeleteClusterCommand = async (input, context) => {
323
- const headers = sharedHeaders("DeleteCluster");
324
- let body;
325
- body = JSON.stringify(se_DeleteClusterRequest(input));
326
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
327
- };
328
- const se_DeleteComputeNodeGroupCommand = async (input, context) => {
329
- const headers = sharedHeaders("DeleteComputeNodeGroup");
330
- let body;
331
- body = JSON.stringify(se_DeleteComputeNodeGroupRequest(input));
332
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
333
- };
334
- const se_DeleteQueueCommand = async (input, context) => {
335
- const headers = sharedHeaders("DeleteQueue");
336
- let body;
337
- body = JSON.stringify(se_DeleteQueueRequest(input));
338
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
339
- };
340
- const se_GetClusterCommand = async (input, context) => {
341
- const headers = sharedHeaders("GetCluster");
342
- let body;
343
- body = JSON.stringify(smithyClient._json(input));
344
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
345
- };
346
- const se_GetComputeNodeGroupCommand = async (input, context) => {
347
- const headers = sharedHeaders("GetComputeNodeGroup");
348
- let body;
349
- body = JSON.stringify(smithyClient._json(input));
350
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
351
- };
352
- const se_GetQueueCommand = async (input, context) => {
353
- const headers = sharedHeaders("GetQueue");
354
- let body;
355
- body = JSON.stringify(smithyClient._json(input));
356
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
357
- };
358
- const se_ListClustersCommand = async (input, context) => {
359
- const headers = sharedHeaders("ListClusters");
360
- let body;
361
- body = JSON.stringify(smithyClient._json(input));
362
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
363
- };
364
- const se_ListComputeNodeGroupsCommand = async (input, context) => {
365
- const headers = sharedHeaders("ListComputeNodeGroups");
366
- let body;
367
- body = JSON.stringify(smithyClient._json(input));
368
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
369
- };
370
- const se_ListQueuesCommand = async (input, context) => {
371
- const headers = sharedHeaders("ListQueues");
372
- let body;
373
- body = JSON.stringify(smithyClient._json(input));
374
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
375
- };
376
- const se_ListTagsForResourceCommand = async (input, context) => {
377
- const headers = sharedHeaders("ListTagsForResource");
378
- let body;
379
- body = JSON.stringify(smithyClient._json(input));
380
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
381
- };
382
- const se_RegisterComputeNodeGroupInstanceCommand = async (input, context) => {
383
- const headers = sharedHeaders("RegisterComputeNodeGroupInstance");
384
- let body;
385
- body = JSON.stringify(smithyClient._json(input));
386
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
387
- };
388
- const se_TagResourceCommand = async (input, context) => {
389
- const headers = sharedHeaders("TagResource");
390
- let body;
391
- body = JSON.stringify(smithyClient._json(input));
392
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
393
- };
394
- const se_UntagResourceCommand = async (input, context) => {
395
- const headers = sharedHeaders("UntagResource");
396
- let body;
397
- body = JSON.stringify(smithyClient._json(input));
398
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
399
- };
400
- const se_UpdateClusterCommand = async (input, context) => {
401
- const headers = sharedHeaders("UpdateCluster");
402
- let body;
403
- body = JSON.stringify(se_UpdateClusterRequest(input));
404
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
405
- };
406
- const se_UpdateComputeNodeGroupCommand = async (input, context) => {
407
- const headers = sharedHeaders("UpdateComputeNodeGroup");
408
- let body;
409
- body = JSON.stringify(se_UpdateComputeNodeGroupRequest(input));
410
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
411
- };
412
- const se_UpdateQueueCommand = async (input, context) => {
413
- const headers = sharedHeaders("UpdateQueue");
414
- let body;
415
- body = JSON.stringify(se_UpdateQueueRequest(input));
416
- return buildHttpRpcRequest(context, headers, "/", undefined, body);
417
- };
418
- const de_CreateClusterCommand = async (output, context) => {
419
- if (output.statusCode >= 300) {
420
- return de_CommandError(output, context);
421
- }
422
- const data = await core$1.parseJsonBody(output.body, context);
423
- let contents = {};
424
- contents = de_CreateClusterResponse(data);
425
- const response = {
426
- $metadata: deserializeMetadata(output),
427
- ...contents,
428
- };
429
- return response;
430
- };
431
- const de_CreateComputeNodeGroupCommand = async (output, context) => {
432
- if (output.statusCode >= 300) {
433
- return de_CommandError(output, context);
434
- }
435
- const data = await core$1.parseJsonBody(output.body, context);
436
- let contents = {};
437
- contents = de_CreateComputeNodeGroupResponse(data);
438
- const response = {
439
- $metadata: deserializeMetadata(output),
440
- ...contents,
441
- };
442
- return response;
443
- };
444
- const de_CreateQueueCommand = async (output, context) => {
445
- if (output.statusCode >= 300) {
446
- return de_CommandError(output, context);
447
- }
448
- const data = await core$1.parseJsonBody(output.body, context);
449
- let contents = {};
450
- contents = de_CreateQueueResponse(data);
451
- const response = {
452
- $metadata: deserializeMetadata(output),
453
- ...contents,
454
- };
455
- return response;
456
- };
457
- const de_DeleteClusterCommand = async (output, context) => {
458
- if (output.statusCode >= 300) {
459
- return de_CommandError(output, context);
460
- }
461
- const data = await core$1.parseJsonBody(output.body, context);
462
- let contents = {};
463
- contents = smithyClient._json(data);
464
- const response = {
465
- $metadata: deserializeMetadata(output),
466
- ...contents,
467
- };
468
- return response;
469
- };
470
- const de_DeleteComputeNodeGroupCommand = async (output, context) => {
471
- if (output.statusCode >= 300) {
472
- return de_CommandError(output, context);
473
- }
474
- const data = await core$1.parseJsonBody(output.body, context);
475
- let contents = {};
476
- contents = smithyClient._json(data);
477
- const response = {
478
- $metadata: deserializeMetadata(output),
479
- ...contents,
480
- };
481
- return response;
482
- };
483
- const de_DeleteQueueCommand = async (output, context) => {
484
- if (output.statusCode >= 300) {
485
- return de_CommandError(output, context);
486
- }
487
- const data = await core$1.parseJsonBody(output.body, context);
488
- let contents = {};
489
- contents = smithyClient._json(data);
490
- const response = {
491
- $metadata: deserializeMetadata(output),
492
- ...contents,
493
- };
494
- return response;
495
- };
496
- const de_GetClusterCommand = async (output, context) => {
497
- if (output.statusCode >= 300) {
498
- return de_CommandError(output, context);
499
- }
500
- const data = await core$1.parseJsonBody(output.body, context);
501
- let contents = {};
502
- contents = de_GetClusterResponse(data);
503
- const response = {
504
- $metadata: deserializeMetadata(output),
505
- ...contents,
506
- };
507
- return response;
508
- };
509
- const de_GetComputeNodeGroupCommand = async (output, context) => {
510
- if (output.statusCode >= 300) {
511
- return de_CommandError(output, context);
512
- }
513
- const data = await core$1.parseJsonBody(output.body, context);
514
- let contents = {};
515
- contents = de_GetComputeNodeGroupResponse(data);
516
- const response = {
517
- $metadata: deserializeMetadata(output),
518
- ...contents,
519
- };
520
- return response;
521
- };
522
- const de_GetQueueCommand = async (output, context) => {
523
- if (output.statusCode >= 300) {
524
- return de_CommandError(output, context);
525
- }
526
- const data = await core$1.parseJsonBody(output.body, context);
527
- let contents = {};
528
- contents = de_GetQueueResponse(data);
529
- const response = {
530
- $metadata: deserializeMetadata(output),
531
- ...contents,
532
- };
533
- return response;
534
- };
535
- const de_ListClustersCommand = async (output, context) => {
536
- if (output.statusCode >= 300) {
537
- return de_CommandError(output, context);
538
- }
539
- const data = await core$1.parseJsonBody(output.body, context);
540
- let contents = {};
541
- contents = de_ListClustersResponse(data);
542
- const response = {
543
- $metadata: deserializeMetadata(output),
544
- ...contents,
545
- };
546
- return response;
547
- };
548
- const de_ListComputeNodeGroupsCommand = async (output, context) => {
549
- if (output.statusCode >= 300) {
550
- return de_CommandError(output, context);
551
- }
552
- const data = await core$1.parseJsonBody(output.body, context);
553
- let contents = {};
554
- contents = de_ListComputeNodeGroupsResponse(data);
555
- const response = {
556
- $metadata: deserializeMetadata(output),
557
- ...contents,
558
- };
559
- return response;
560
- };
561
- const de_ListQueuesCommand = async (output, context) => {
562
- if (output.statusCode >= 300) {
563
- return de_CommandError(output, context);
564
- }
565
- const data = await core$1.parseJsonBody(output.body, context);
566
- let contents = {};
567
- contents = de_ListQueuesResponse(data);
568
- const response = {
569
- $metadata: deserializeMetadata(output),
570
- ...contents,
571
- };
572
- return response;
573
- };
574
- const de_ListTagsForResourceCommand = async (output, context) => {
575
- if (output.statusCode >= 300) {
576
- return de_CommandError(output, context);
577
- }
578
- const data = await core$1.parseJsonBody(output.body, context);
579
- let contents = {};
580
- contents = smithyClient._json(data);
581
- const response = {
582
- $metadata: deserializeMetadata(output),
583
- ...contents,
584
- };
585
- return response;
586
- };
587
- const de_RegisterComputeNodeGroupInstanceCommand = async (output, context) => {
588
- if (output.statusCode >= 300) {
589
- return de_CommandError(output, context);
590
- }
591
- const data = await core$1.parseJsonBody(output.body, context);
592
- let contents = {};
593
- contents = smithyClient._json(data);
594
- const response = {
595
- $metadata: deserializeMetadata(output),
596
- ...contents,
597
- };
598
- return response;
599
- };
600
- const de_TagResourceCommand = async (output, context) => {
601
- if (output.statusCode >= 300) {
602
- return de_CommandError(output, context);
603
- }
604
- await smithyClient.collectBody(output.body, context);
605
- const response = {
606
- $metadata: deserializeMetadata(output),
607
- };
608
- return response;
609
- };
610
- const de_UntagResourceCommand = async (output, context) => {
611
- if (output.statusCode >= 300) {
612
- return de_CommandError(output, context);
613
- }
614
- await smithyClient.collectBody(output.body, context);
615
- const response = {
616
- $metadata: deserializeMetadata(output),
617
- };
618
- return response;
619
- };
620
- const de_UpdateClusterCommand = async (output, context) => {
621
- if (output.statusCode >= 300) {
622
- return de_CommandError(output, context);
623
- }
624
- const data = await core$1.parseJsonBody(output.body, context);
625
- let contents = {};
626
- contents = de_UpdateClusterResponse(data);
627
- const response = {
628
- $metadata: deserializeMetadata(output),
629
- ...contents,
630
- };
631
- return response;
632
- };
633
- const de_UpdateComputeNodeGroupCommand = async (output, context) => {
634
- if (output.statusCode >= 300) {
635
- return de_CommandError(output, context);
636
- }
637
- const data = await core$1.parseJsonBody(output.body, context);
638
- let contents = {};
639
- contents = de_UpdateComputeNodeGroupResponse(data);
640
- const response = {
641
- $metadata: deserializeMetadata(output),
642
- ...contents,
643
- };
644
- return response;
645
- };
646
- const de_UpdateQueueCommand = async (output, context) => {
647
- if (output.statusCode >= 300) {
648
- return de_CommandError(output, context);
649
- }
650
- const data = await core$1.parseJsonBody(output.body, context);
651
- let contents = {};
652
- contents = de_UpdateQueueResponse(data);
653
- const response = {
654
- $metadata: deserializeMetadata(output),
655
- ...contents,
656
- };
657
- return response;
658
- };
659
- const de_CommandError = async (output, context) => {
660
- const parsedOutput = {
661
- ...output,
662
- body: await core$1.parseJsonErrorBody(output.body, context),
663
- };
664
- const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
665
- switch (errorCode) {
666
- case "AccessDeniedException":
667
- case "com.amazonaws.pcs#AccessDeniedException":
668
- throw await de_AccessDeniedExceptionRes(parsedOutput);
669
- case "ConflictException":
670
- case "com.amazonaws.pcs#ConflictException":
671
- throw await de_ConflictExceptionRes(parsedOutput);
672
- case "InternalServerException":
673
- case "com.amazonaws.pcs#InternalServerException":
674
- throw await de_InternalServerExceptionRes(parsedOutput);
675
- case "ServiceQuotaExceededException":
676
- case "com.amazonaws.pcs#ServiceQuotaExceededException":
677
- throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
678
- case "ThrottlingException":
679
- case "com.amazonaws.pcs#ThrottlingException":
680
- throw await de_ThrottlingExceptionRes(parsedOutput);
681
- case "ValidationException":
682
- case "com.amazonaws.pcs#ValidationException":
683
- throw await de_ValidationExceptionRes(parsedOutput);
684
- case "ResourceNotFoundException":
685
- case "com.amazonaws.pcs#ResourceNotFoundException":
686
- throw await de_ResourceNotFoundExceptionRes(parsedOutput);
687
- default:
688
- const parsedBody = parsedOutput.body;
689
- return throwDefaultError({
690
- output,
691
- parsedBody,
692
- errorCode,
693
- });
694
- }
695
- };
696
- const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
697
- const body = parsedOutput.body;
698
- const deserialized = smithyClient._json(body);
699
- const exception = new AccessDeniedException({
700
- $metadata: deserializeMetadata(parsedOutput),
701
- ...deserialized,
702
- });
703
- return smithyClient.decorateServiceException(exception, body);
704
- };
705
- const de_ConflictExceptionRes = async (parsedOutput, context) => {
706
- const body = parsedOutput.body;
707
- const deserialized = smithyClient._json(body);
708
- const exception = new ConflictException({
709
- $metadata: deserializeMetadata(parsedOutput),
710
- ...deserialized,
711
- });
712
- return smithyClient.decorateServiceException(exception, body);
713
- };
714
- const de_InternalServerExceptionRes = async (parsedOutput, context) => {
715
- const body = parsedOutput.body;
716
- const deserialized = smithyClient._json(body);
717
- const exception = new InternalServerException({
718
- $metadata: deserializeMetadata(parsedOutput),
719
- ...deserialized,
720
- });
721
- return smithyClient.decorateServiceException(exception, body);
722
- };
723
- const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
724
- const body = parsedOutput.body;
725
- const deserialized = smithyClient._json(body);
726
- const exception = new ResourceNotFoundException({
727
- $metadata: deserializeMetadata(parsedOutput),
728
- ...deserialized,
729
- });
730
- return smithyClient.decorateServiceException(exception, body);
731
- };
732
- const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
733
- const body = parsedOutput.body;
734
- const deserialized = smithyClient._json(body);
735
- const exception = new ServiceQuotaExceededException({
736
- $metadata: deserializeMetadata(parsedOutput),
737
- ...deserialized,
738
- });
739
- return smithyClient.decorateServiceException(exception, body);
740
- };
741
- const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
742
- const body = parsedOutput.body;
743
- const deserialized = smithyClient._json(body);
744
- const exception = new ThrottlingException({
745
- $metadata: deserializeMetadata(parsedOutput),
746
- ...deserialized,
747
- });
748
- return smithyClient.decorateServiceException(exception, body);
749
- };
750
- const de_ValidationExceptionRes = async (parsedOutput, context) => {
751
- const body = parsedOutput.body;
752
- const deserialized = smithyClient._json(body);
753
- const exception = new ValidationException({
754
- $metadata: deserializeMetadata(parsedOutput),
755
- ...deserialized,
756
- });
757
- return smithyClient.decorateServiceException(exception, body);
758
- };
759
- const se_CreateClusterRequest = (input, context) => {
760
- return smithyClient.take(input, {
761
- clientToken: [true, (_) => _ ?? uuid.v4()],
762
- clusterName: [],
763
- networking: smithyClient._json,
764
- scheduler: smithyClient._json,
765
- size: [],
766
- slurmConfiguration: smithyClient._json,
767
- tags: smithyClient._json,
768
- });
769
- };
770
- const se_CreateComputeNodeGroupRequest = (input, context) => {
771
- return smithyClient.take(input, {
772
- amiId: [],
773
- clientToken: [true, (_) => _ ?? uuid.v4()],
774
- clusterIdentifier: [],
775
- computeNodeGroupName: [],
776
- customLaunchTemplate: smithyClient._json,
777
- iamInstanceProfileArn: [],
778
- instanceConfigs: smithyClient._json,
779
- purchaseOption: [],
780
- scalingConfiguration: smithyClient._json,
781
- slurmConfiguration: smithyClient._json,
782
- spotOptions: smithyClient._json,
783
- subnetIds: smithyClient._json,
784
- tags: smithyClient._json,
785
- });
786
- };
787
- const se_CreateQueueRequest = (input, context) => {
788
- return smithyClient.take(input, {
789
- clientToken: [true, (_) => _ ?? uuid.v4()],
790
- clusterIdentifier: [],
791
- computeNodeGroupConfigurations: smithyClient._json,
792
- queueName: [],
793
- slurmConfiguration: smithyClient._json,
794
- tags: smithyClient._json,
795
- });
796
- };
797
- const se_DeleteClusterRequest = (input, context) => {
798
- return smithyClient.take(input, {
799
- clientToken: [true, (_) => _ ?? uuid.v4()],
800
- clusterIdentifier: [],
801
- });
802
- };
803
- const se_DeleteComputeNodeGroupRequest = (input, context) => {
804
- return smithyClient.take(input, {
805
- clientToken: [true, (_) => _ ?? uuid.v4()],
806
- clusterIdentifier: [],
807
- computeNodeGroupIdentifier: [],
808
- });
809
- };
810
- const se_DeleteQueueRequest = (input, context) => {
811
- return smithyClient.take(input, {
812
- clientToken: [true, (_) => _ ?? uuid.v4()],
813
- clusterIdentifier: [],
814
- queueIdentifier: [],
815
- });
816
- };
817
- const se_UpdateClusterRequest = (input, context) => {
818
- return smithyClient.take(input, {
819
- clientToken: [true, (_) => _ ?? uuid.v4()],
820
- clusterIdentifier: [],
821
- slurmConfiguration: smithyClient._json,
822
- });
823
- };
824
- const se_UpdateComputeNodeGroupRequest = (input, context) => {
825
- return smithyClient.take(input, {
826
- amiId: [],
827
- clientToken: [true, (_) => _ ?? uuid.v4()],
828
- clusterIdentifier: [],
829
- computeNodeGroupIdentifier: [],
830
- customLaunchTemplate: smithyClient._json,
831
- iamInstanceProfileArn: [],
832
- purchaseOption: [],
833
- scalingConfiguration: smithyClient._json,
834
- slurmConfiguration: smithyClient._json,
835
- spotOptions: smithyClient._json,
836
- subnetIds: smithyClient._json,
837
- });
838
- };
839
- const se_UpdateQueueRequest = (input, context) => {
840
- return smithyClient.take(input, {
841
- clientToken: [true, (_) => _ ?? uuid.v4()],
842
- clusterIdentifier: [],
843
- computeNodeGroupConfigurations: smithyClient._json,
844
- queueIdentifier: [],
845
- slurmConfiguration: smithyClient._json,
846
- });
847
- };
848
- const de_Cluster = (output, context) => {
849
- return smithyClient.take(output, {
850
- arn: smithyClient.expectString,
851
- createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
852
- endpoints: smithyClient._json,
853
- errorInfo: smithyClient._json,
854
- id: smithyClient.expectString,
855
- modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
856
- name: smithyClient.expectString,
857
- networking: smithyClient._json,
858
- scheduler: smithyClient._json,
859
- size: smithyClient.expectString,
860
- slurmConfiguration: smithyClient._json,
861
- status: smithyClient.expectString,
862
- });
863
- };
864
- const de_ClusterList = (output, context) => {
865
- const retVal = (output || [])
866
- .filter((e) => e != null)
867
- .map((entry) => {
868
- return de_ClusterSummary(entry);
869
- });
870
- return retVal;
871
- };
872
- const de_ClusterSummary = (output, context) => {
873
- return smithyClient.take(output, {
874
- arn: smithyClient.expectString,
875
- createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
876
- id: smithyClient.expectString,
877
- modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
878
- name: smithyClient.expectString,
879
- status: smithyClient.expectString,
880
- });
881
- };
882
- const de_ComputeNodeGroup = (output, context) => {
883
- return smithyClient.take(output, {
884
- amiId: smithyClient.expectString,
885
- arn: smithyClient.expectString,
886
- clusterId: smithyClient.expectString,
887
- createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
888
- customLaunchTemplate: smithyClient._json,
889
- errorInfo: smithyClient._json,
890
- iamInstanceProfileArn: smithyClient.expectString,
891
- id: smithyClient.expectString,
892
- instanceConfigs: smithyClient._json,
893
- modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
894
- name: smithyClient.expectString,
895
- purchaseOption: smithyClient.expectString,
896
- scalingConfiguration: smithyClient._json,
897
- slurmConfiguration: smithyClient._json,
898
- spotOptions: smithyClient._json,
899
- status: smithyClient.expectString,
900
- subnetIds: smithyClient._json,
901
- });
902
- };
903
- const de_ComputeNodeGroupList = (output, context) => {
904
- const retVal = (output || [])
905
- .filter((e) => e != null)
906
- .map((entry) => {
907
- return de_ComputeNodeGroupSummary(entry);
908
- });
909
- return retVal;
910
- };
911
- const de_ComputeNodeGroupSummary = (output, context) => {
912
- return smithyClient.take(output, {
913
- arn: smithyClient.expectString,
914
- clusterId: smithyClient.expectString,
915
- createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
916
- id: smithyClient.expectString,
917
- modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
918
- name: smithyClient.expectString,
919
- status: smithyClient.expectString,
920
- });
921
- };
922
- const de_CreateClusterResponse = (output, context) => {
923
- return smithyClient.take(output, {
924
- cluster: (_) => de_Cluster(_),
925
- });
926
- };
927
- const de_CreateComputeNodeGroupResponse = (output, context) => {
928
- return smithyClient.take(output, {
929
- computeNodeGroup: (_) => de_ComputeNodeGroup(_),
930
- });
931
- };
932
- const de_CreateQueueResponse = (output, context) => {
933
- return smithyClient.take(output, {
934
- queue: (_) => de_Queue(_),
935
- });
936
- };
937
- const de_GetClusterResponse = (output, context) => {
938
- return smithyClient.take(output, {
939
- cluster: (_) => de_Cluster(_),
940
- });
941
- };
942
- const de_GetComputeNodeGroupResponse = (output, context) => {
943
- return smithyClient.take(output, {
944
- computeNodeGroup: (_) => de_ComputeNodeGroup(_),
945
- });
946
- };
947
- const de_GetQueueResponse = (output, context) => {
948
- return smithyClient.take(output, {
949
- queue: (_) => de_Queue(_),
950
- });
951
- };
952
- const de_ListClustersResponse = (output, context) => {
953
- return smithyClient.take(output, {
954
- clusters: (_) => de_ClusterList(_),
955
- nextToken: smithyClient.expectString,
956
- });
957
- };
958
- const de_ListComputeNodeGroupsResponse = (output, context) => {
959
- return smithyClient.take(output, {
960
- computeNodeGroups: (_) => de_ComputeNodeGroupList(_),
961
- nextToken: smithyClient.expectString,
962
- });
963
- };
964
- const de_ListQueuesResponse = (output, context) => {
965
- return smithyClient.take(output, {
966
- nextToken: smithyClient.expectString,
967
- queues: (_) => de_QueueList(_),
968
- });
969
- };
970
- const de_Queue = (output, context) => {
971
- return smithyClient.take(output, {
972
- arn: smithyClient.expectString,
973
- clusterId: smithyClient.expectString,
974
- computeNodeGroupConfigurations: smithyClient._json,
975
- createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
976
- errorInfo: smithyClient._json,
977
- id: smithyClient.expectString,
978
- modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
979
- name: smithyClient.expectString,
980
- slurmConfiguration: smithyClient._json,
981
- status: smithyClient.expectString,
982
- });
983
- };
984
- const de_QueueList = (output, context) => {
985
- const retVal = (output || [])
986
- .filter((e) => e != null)
987
- .map((entry) => {
988
- return de_QueueSummary(entry);
989
- });
990
- return retVal;
991
- };
992
- const de_QueueSummary = (output, context) => {
993
- return smithyClient.take(output, {
994
- arn: smithyClient.expectString,
995
- clusterId: smithyClient.expectString,
996
- createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
997
- id: smithyClient.expectString,
998
- modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
999
- name: smithyClient.expectString,
1000
- status: smithyClient.expectString,
1001
- });
1002
- };
1003
- const de_UpdateClusterResponse = (output, context) => {
1004
- return smithyClient.take(output, {
1005
- cluster: (_) => de_Cluster(_),
1006
- });
1007
- };
1008
- const de_UpdateComputeNodeGroupResponse = (output, context) => {
1009
- return smithyClient.take(output, {
1010
- computeNodeGroup: (_) => de_ComputeNodeGroup(_),
1011
- });
1012
- };
1013
- const de_UpdateQueueResponse = (output, context) => {
1014
- return smithyClient.take(output, {
1015
- queue: (_) => de_Queue(_),
1016
- });
1017
- };
1018
- const deserializeMetadata = (output) => ({
1019
- httpStatusCode: output.statusCode,
1020
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1021
- extendedRequestId: output.headers["x-amz-id-2"],
1022
- cfId: output.headers["x-amz-cf-id"],
1023
- });
1024
- const throwDefaultError = smithyClient.withBaseException(PCSServiceException);
1025
- const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
1026
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1027
- const contents = {
1028
- protocol,
1029
- hostname,
1030
- port,
1031
- method: "POST",
1032
- path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
1033
- headers,
1034
- };
1035
- if (body !== undefined) {
1036
- contents.body = body;
1037
- }
1038
- return new protocolHttp.HttpRequest(contents);
1039
- };
1040
- function sharedHeaders(operation) {
1041
- return {
1042
- "content-type": "application/x-amz-json-1.0",
1043
- "x-amz-target": `AWSParallelComputingService.${operation}`,
1044
- };
1045
- }
299
+ const _A = "Accounting";
300
+ const _ADE = "AccessDeniedException";
301
+ const _AR = "AccountingRequest";
302
+ const _C = "Cluster";
303
+ const _CC = "CreateCluster";
304
+ const _CCNG = "CreateComputeNodeGroup";
305
+ const _CCNGR = "CreateComputeNodeGroupRequest";
306
+ const _CCNGRr = "CreateComputeNodeGroupResponse";
307
+ const _CCR = "CreateClusterRequest";
308
+ const _CCRr = "CreateClusterResponse";
309
+ const _CE = "ConflictException";
310
+ const _CL = "ClusterList";
311
+ const _CLT = "CustomLaunchTemplate";
312
+ const _CNG = "ComputeNodeGroup";
313
+ const _CNGC = "ComputeNodeGroupConfiguration";
314
+ const _CNGCL = "ComputeNodeGroupConfigurationList";
315
+ const _CNGL = "ComputeNodeGroupList";
316
+ const _CNGS = "ComputeNodeGroupSummary";
317
+ const _CNGSC = "ComputeNodeGroupSlurmConfiguration";
318
+ const _CNGSCR = "ComputeNodeGroupSlurmConfigurationRequest";
319
+ const _CQ = "CreateQueue";
320
+ const _CQR = "CreateQueueRequest";
321
+ const _CQRr = "CreateQueueResponse";
322
+ const _CS = "ClusterSummary";
323
+ const _CSC = "ClusterSlurmConfiguration";
324
+ const _CSCR = "ClusterSlurmConfigurationRequest";
325
+ const _DC = "DeleteCluster";
326
+ const _DCNG = "DeleteComputeNodeGroup";
327
+ const _DCNGR = "DeleteComputeNodeGroupRequest";
328
+ const _DCNGRe = "DeleteComputeNodeGroupResponse";
329
+ const _DCR = "DeleteClusterRequest";
330
+ const _DCRe = "DeleteClusterResponse";
331
+ const _DQ = "DeleteQueue";
332
+ const _DQR = "DeleteQueueRequest";
333
+ const _DQRe = "DeleteQueueResponse";
334
+ const _E = "Endpoint";
335
+ const _EI = "ErrorInfo";
336
+ const _EIL = "ErrorInfoList";
337
+ const _En = "Endpoints";
338
+ const _GC = "GetCluster";
339
+ const _GCNG = "GetComputeNodeGroup";
340
+ const _GCNGR = "GetComputeNodeGroupRequest";
341
+ const _GCNGRe = "GetComputeNodeGroupResponse";
342
+ const _GCR = "GetClusterRequest";
343
+ const _GCRe = "GetClusterResponse";
344
+ const _GQ = "GetQueue";
345
+ const _GQR = "GetQueueRequest";
346
+ const _GQRe = "GetQueueResponse";
347
+ const _IC = "InstanceConfig";
348
+ const _IL = "InstanceList";
349
+ const _ISE = "InternalServerException";
350
+ const _LC = "ListClusters";
351
+ const _LCNG = "ListComputeNodeGroups";
352
+ const _LCNGR = "ListComputeNodeGroupsRequest";
353
+ const _LCNGRi = "ListComputeNodeGroupsResponse";
354
+ const _LCR = "ListClustersRequest";
355
+ const _LCRi = "ListClustersResponse";
356
+ const _LQ = "ListQueues";
357
+ const _LQR = "ListQueuesRequest";
358
+ const _LQRi = "ListQueuesResponse";
359
+ const _LTFR = "ListTagsForResource";
360
+ const _LTFRR = "ListTagsForResourceRequest";
361
+ const _LTFRRi = "ListTagsForResourceResponse";
362
+ const _N = "Networking";
363
+ const _NR = "NetworkingRequest";
364
+ const _Q = "Queue";
365
+ const _QL = "QueueList";
366
+ const _QS = "QueueSummary";
367
+ const _QSC = "QueueSlurmConfiguration";
368
+ const _QSCR = "QueueSlurmConfigurationRequest";
369
+ const _RA = "Retry-After";
370
+ const _RCNGI = "RegisterComputeNodeGroupInstance";
371
+ const _RCNGIR = "RegisterComputeNodeGroupInstanceRequest";
372
+ const _RCNGIRe = "RegisterComputeNodeGroupInstanceResponse";
373
+ const _RNFE = "ResourceNotFoundException";
374
+ const _S = "Scheduler";
375
+ const _SAK = "SlurmAuthKey";
376
+ const _SC = "ScalingConfiguration";
377
+ const _SCR = "ScalingConfigurationRequest";
378
+ const _SCS = "SlurmCustomSetting";
379
+ const _SCSl = "SlurmCustomSettings";
380
+ const _SO = "SpotOptions";
381
+ const _SQEE = "ServiceQuotaExceededException";
382
+ const _SR = "SchedulerRequest";
383
+ const _SS = "SharedSecret";
384
+ const _TE = "ThrottlingException";
385
+ const _TR = "TagResource";
386
+ const _TRR = "TagResourceRequest";
387
+ const _UAR = "UpdateAccountingRequest";
388
+ const _UC = "UpdateCluster";
389
+ const _UCNG = "UpdateComputeNodeGroup";
390
+ const _UCNGR = "UpdateComputeNodeGroupRequest";
391
+ const _UCNGRp = "UpdateComputeNodeGroupResponse";
392
+ const _UCNGSCR = "UpdateComputeNodeGroupSlurmConfigurationRequest";
393
+ const _UCR = "UpdateClusterRequest";
394
+ const _UCRp = "UpdateClusterResponse";
395
+ const _UCSCR = "UpdateClusterSlurmConfigurationRequest";
396
+ const _UQ = "UpdateQueue";
397
+ const _UQR = "UpdateQueueRequest";
398
+ const _UQRp = "UpdateQueueResponse";
399
+ const _UQSCR = "UpdateQueueSlurmConfigurationRequest";
400
+ const _UR = "UntagResource";
401
+ const _URR = "UntagResourceRequest";
402
+ const _VE = "ValidationException";
403
+ const _VEF = "ValidationExceptionField";
404
+ const _VEFL = "ValidationExceptionFieldList";
405
+ const _a = "arn";
406
+ const _aI = "amiId";
407
+ const _aK = "authKey";
408
+ const _aS = "allocationStrategy";
409
+ const _ac = "accounting";
410
+ const _bI = "bootstrapId";
411
+ const _c = "client";
412
+ const _cA = "createdAt";
413
+ const _cI = "clusterId";
414
+ const _cIl = "clusterIdentifier";
415
+ const _cLT = "customLaunchTemplate";
416
+ const _cN = "clusterName";
417
+ const _cNG = "computeNodeGroup";
418
+ const _cNGC = "computeNodeGroupConfigurations";
419
+ const _cNGI = "computeNodeGroupId";
420
+ const _cNGIo = "computeNodeGroupIdentifier";
421
+ const _cNGN = "computeNodeGroupName";
422
+ const _cNGo = "computeNodeGroups";
423
+ const _cT = "clientToken";
424
+ const _cl = "cluster";
425
+ const _clu = "clusters";
426
+ const _co = "code";
427
+ const _dPTID = "defaultPurgeTimeInDays";
428
+ const _e = "error";
429
+ const _eI = "errorInfo";
430
+ const _en = "endpoints";
431
+ const _fL = "fieldList";
432
+ const _hE = "httpError";
433
+ const _hH = "httpHeader";
434
+ const _hQ = "httpQuery";
435
+ const _i = "id";
436
+ const _iA = "ipv6Address";
437
+ const _iC = "instanceConfigs";
438
+ const _iIPA = "iamInstanceProfileArn";
439
+ const _iT = "instanceType";
440
+ const _m = "message";
441
+ const _mA = "modifiedAt";
442
+ const _mIC = "minInstanceCount";
443
+ const _mICa = "maxInstanceCount";
444
+ const _mR = "maxResults";
445
+ const _mo = "mode";
446
+ const _n = "name";
447
+ const _nID = "nodeID";
448
+ const _nT = "nextToken";
449
+ const _nTe = "networkType";
450
+ const _ne = "networking";
451
+ const _p = "port";
452
+ const _pIA = "privateIpAddress";
453
+ const _pIAu = "publicIpAddress";
454
+ const _pN = "parameterName";
455
+ const _pO = "purchaseOption";
456
+ const _pV = "parameterValue";
457
+ const _q = "queue";
458
+ const _qC = "quotaCode";
459
+ const _qI = "queueIdentifier";
460
+ const _qN = "queueName";
461
+ const _qu = "queues";
462
+ const _r = "reason";
463
+ const _rA = "resourceArn";
464
+ const _rAS = "retryAfterSeconds";
465
+ const _rI = "resourceId";
466
+ const _rT = "resourceType";
467
+ const _s = "status";
468
+ const _sA = "secretArn";
469
+ const _sC = "slurmConfiguration";
470
+ const _sCS = "slurmCustomSettings";
471
+ const _sCc = "scalingConfiguration";
472
+ const _sCe = "serviceCode";
473
+ const _sDITIS = "scaleDownIdleTimeInSeconds";
474
+ const _sGI = "securityGroupIds";
475
+ const _sI = "subnetIds";
476
+ const _sO = "spotOptions";
477
+ const _sS = "sharedSecret";
478
+ const _sV = "secretVersion";
479
+ const _sc = "scheduler";
480
+ const _se = "server";
481
+ const _si = "size";
482
+ const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.pcs";
483
+ const _t = "tags";
484
+ const _tK = "tagKeys";
485
+ const _ty = "type";
486
+ const _v = "version";
487
+ const n0 = "com.amazonaws.pcs";
488
+ var SharedSecret = [0, n0, _SS, 8, 0];
489
+ var AccessDeniedException = [
490
+ -3,
491
+ n0,
492
+ _ADE,
493
+ {
494
+ [_e]: _c,
495
+ [_hE]: 403,
496
+ },
497
+ [_m],
498
+ [0],
499
+ ];
500
+ schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
501
+ var Accounting = [3, n0, _A, 0, [_dPTID, _mo], [1, 0]];
502
+ var AccountingRequest = [3, n0, _AR, 0, [_dPTID, _mo], [1, 0]];
503
+ var Cluster = [
504
+ 3,
505
+ n0,
506
+ _C,
507
+ 0,
508
+ [_n, _i, _a, _s, _cA, _mA, _sc, _si, _sC, _ne, _en, _eI],
509
+ [
510
+ 0,
511
+ 0,
512
+ 0,
513
+ 0,
514
+ 5,
515
+ 5,
516
+ () => Scheduler,
517
+ 0,
518
+ () => ClusterSlurmConfiguration,
519
+ () => Networking,
520
+ () => Endpoints,
521
+ () => ErrorInfoList,
522
+ ],
523
+ ];
524
+ var ClusterSlurmConfiguration = [
525
+ 3,
526
+ n0,
527
+ _CSC,
528
+ 0,
529
+ [_sDITIS, _sCS, _aK, _ac],
530
+ [1, () => SlurmCustomSettings, () => SlurmAuthKey, () => Accounting],
531
+ ];
532
+ var ClusterSlurmConfigurationRequest = [
533
+ 3,
534
+ n0,
535
+ _CSCR,
536
+ 0,
537
+ [_sDITIS, _sCS, _ac],
538
+ [1, () => SlurmCustomSettings, () => AccountingRequest],
539
+ ];
540
+ var ClusterSummary = [3, n0, _CS, 0, [_n, _i, _a, _cA, _mA, _s], [0, 0, 0, 5, 5, 0]];
541
+ var ComputeNodeGroup = [
542
+ 3,
543
+ n0,
544
+ _CNG,
545
+ 0,
546
+ [_n, _i, _a, _cI, _cA, _mA, _s, _aI, _sI, _pO, _cLT, _iIPA, _sCc, _iC, _sO, _sC, _eI],
547
+ [
548
+ 0,
549
+ 0,
550
+ 0,
551
+ 0,
552
+ 5,
553
+ 5,
554
+ 0,
555
+ 0,
556
+ 64 | 0,
557
+ 0,
558
+ () => CustomLaunchTemplate,
559
+ 0,
560
+ () => ScalingConfiguration,
561
+ () => InstanceList,
562
+ () => SpotOptions,
563
+ () => ComputeNodeGroupSlurmConfiguration,
564
+ () => ErrorInfoList,
565
+ ],
566
+ ];
567
+ var ComputeNodeGroupConfiguration = [3, n0, _CNGC, 0, [_cNGI], [0]];
568
+ var ComputeNodeGroupSlurmConfiguration = [
569
+ 3,
570
+ n0,
571
+ _CNGSC,
572
+ 0,
573
+ [_sCS],
574
+ [() => SlurmCustomSettings],
575
+ ];
576
+ var ComputeNodeGroupSlurmConfigurationRequest = [
577
+ 3,
578
+ n0,
579
+ _CNGSCR,
580
+ 0,
581
+ [_sCS],
582
+ [() => SlurmCustomSettings],
583
+ ];
584
+ var ComputeNodeGroupSummary = [
585
+ 3,
586
+ n0,
587
+ _CNGS,
588
+ 0,
589
+ [_n, _i, _a, _cI, _cA, _mA, _s],
590
+ [0, 0, 0, 0, 5, 5, 0],
591
+ ];
592
+ var ConflictException = [
593
+ -3,
594
+ n0,
595
+ _CE,
596
+ {
597
+ [_e]: _c,
598
+ [_hE]: 409,
599
+ },
600
+ [_m, _rI, _rT],
601
+ [0, 0, 0],
602
+ ];
603
+ schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
604
+ var CreateClusterRequest = [
605
+ 3,
606
+ n0,
607
+ _CCR,
608
+ 0,
609
+ [_cN, _sc, _si, _ne, _sC, _cT, _t],
610
+ [0, () => SchedulerRequest, 0, () => NetworkingRequest, () => ClusterSlurmConfigurationRequest, [0, 4], 128 | 0],
611
+ ];
612
+ var CreateClusterResponse = [3, n0, _CCRr, 0, [_cl], [() => Cluster]];
613
+ var CreateComputeNodeGroupRequest = [
614
+ 3,
615
+ n0,
616
+ _CCNGR,
617
+ 0,
618
+ [_cIl, _cNGN, _aI, _sI, _pO, _cLT, _iIPA, _sCc, _iC, _sO, _sC, _cT, _t],
619
+ [
620
+ 0,
621
+ 0,
622
+ 0,
623
+ 64 | 0,
624
+ 0,
625
+ () => CustomLaunchTemplate,
626
+ 0,
627
+ () => ScalingConfigurationRequest,
628
+ () => InstanceList,
629
+ () => SpotOptions,
630
+ () => ComputeNodeGroupSlurmConfigurationRequest,
631
+ [0, 4],
632
+ 128 | 0,
633
+ ],
634
+ ];
635
+ var CreateComputeNodeGroupResponse = [
636
+ 3,
637
+ n0,
638
+ _CCNGRr,
639
+ 0,
640
+ [_cNG],
641
+ [() => ComputeNodeGroup],
642
+ ];
643
+ var CreateQueueRequest = [
644
+ 3,
645
+ n0,
646
+ _CQR,
647
+ 0,
648
+ [_cIl, _qN, _cNGC, _sC, _cT, _t],
649
+ [0, 0, () => ComputeNodeGroupConfigurationList, () => QueueSlurmConfigurationRequest, [0, 4], 128 | 0],
650
+ ];
651
+ var CreateQueueResponse = [3, n0, _CQRr, 0, [_q], [() => Queue]];
652
+ var CustomLaunchTemplate = [3, n0, _CLT, 0, [_i, _v], [0, 0]];
653
+ var DeleteClusterRequest = [3, n0, _DCR, 0, [_cIl, _cT], [0, [0, 4]]];
654
+ var DeleteClusterResponse = [3, n0, _DCRe, 0, [], []];
655
+ var DeleteComputeNodeGroupRequest = [
656
+ 3,
657
+ n0,
658
+ _DCNGR,
659
+ 0,
660
+ [_cIl, _cNGIo, _cT],
661
+ [0, 0, [0, 4]],
662
+ ];
663
+ var DeleteComputeNodeGroupResponse = [3, n0, _DCNGRe, 0, [], []];
664
+ var DeleteQueueRequest = [3, n0, _DQR, 0, [_cIl, _qI, _cT], [0, 0, [0, 4]]];
665
+ var DeleteQueueResponse = [3, n0, _DQRe, 0, [], []];
666
+ var Endpoint = [3, n0, _E, 0, [_ty, _pIA, _pIAu, _iA, _p], [0, 0, 0, 0, 0]];
667
+ var ErrorInfo = [3, n0, _EI, 0, [_co, _m], [0, 0]];
668
+ var GetClusterRequest = [3, n0, _GCR, 0, [_cIl], [0]];
669
+ var GetClusterResponse = [3, n0, _GCRe, 0, [_cl], [() => Cluster]];
670
+ var GetComputeNodeGroupRequest = [3, n0, _GCNGR, 0, [_cIl, _cNGIo], [0, 0]];
671
+ var GetComputeNodeGroupResponse = [3, n0, _GCNGRe, 0, [_cNG], [() => ComputeNodeGroup]];
672
+ var GetQueueRequest = [3, n0, _GQR, 0, [_cIl, _qI], [0, 0]];
673
+ var GetQueueResponse = [3, n0, _GQRe, 0, [_q], [() => Queue]];
674
+ var InstanceConfig = [3, n0, _IC, 0, [_iT], [0]];
675
+ var InternalServerException = [
676
+ -3,
677
+ n0,
678
+ _ISE,
679
+ {
680
+ [_e]: _se,
681
+ [_hE]: 500,
682
+ },
683
+ [_m],
684
+ [0],
685
+ ];
686
+ schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
687
+ var ListClustersRequest = [
688
+ 3,
689
+ n0,
690
+ _LCR,
691
+ 0,
692
+ [_nT, _mR],
693
+ [
694
+ [
695
+ 0,
696
+ {
697
+ [_hQ]: _nT,
698
+ },
699
+ ],
700
+ [
701
+ 1,
702
+ {
703
+ [_hQ]: _mR,
704
+ },
705
+ ],
706
+ ],
707
+ ];
708
+ var ListClustersResponse = [3, n0, _LCRi, 0, [_clu, _nT], [() => ClusterList, 0]];
709
+ var ListComputeNodeGroupsRequest = [3, n0, _LCNGR, 0, [_cIl, _nT, _mR], [0, 0, 1]];
710
+ var ListComputeNodeGroupsResponse = [
711
+ 3,
712
+ n0,
713
+ _LCNGRi,
714
+ 0,
715
+ [_cNGo, _nT],
716
+ [() => ComputeNodeGroupList, 0],
717
+ ];
718
+ var ListQueuesRequest = [3, n0, _LQR, 0, [_cIl, _nT, _mR], [0, 0, 1]];
719
+ var ListQueuesResponse = [3, n0, _LQRi, 0, [_qu, _nT], [() => QueueList, 0]];
720
+ var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [0]];
721
+ var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [128 | 0]];
722
+ var Networking = [3, n0, _N, 0, [_sI, _sGI, _nTe], [64 | 0, 64 | 0, 0]];
723
+ var NetworkingRequest = [3, n0, _NR, 0, [_sI, _sGI, _nTe], [64 | 0, 64 | 0, 0]];
724
+ var Queue = [
725
+ 3,
726
+ n0,
727
+ _Q,
728
+ 0,
729
+ [_n, _i, _a, _cI, _cA, _mA, _s, _cNGC, _sC, _eI],
730
+ [0, 0, 0, 0, 5, 5, 0, () => ComputeNodeGroupConfigurationList, () => QueueSlurmConfiguration, () => ErrorInfoList],
731
+ ];
732
+ var QueueSlurmConfiguration = [3, n0, _QSC, 0, [_sCS], [() => SlurmCustomSettings]];
733
+ var QueueSlurmConfigurationRequest = [
734
+ 3,
735
+ n0,
736
+ _QSCR,
737
+ 0,
738
+ [_sCS],
739
+ [() => SlurmCustomSettings],
740
+ ];
741
+ var QueueSummary = [
742
+ 3,
743
+ n0,
744
+ _QS,
745
+ 0,
746
+ [_n, _i, _a, _cI, _cA, _mA, _s],
747
+ [0, 0, 0, 0, 5, 5, 0],
748
+ ];
749
+ var RegisterComputeNodeGroupInstanceRequest = [3, n0, _RCNGIR, 0, [_cIl, _bI], [0, 0]];
750
+ var RegisterComputeNodeGroupInstanceResponse = [
751
+ 3,
752
+ n0,
753
+ _RCNGIRe,
754
+ 0,
755
+ [_nID, _sS, _en],
756
+ [0, [() => SharedSecret, 0], () => Endpoints],
757
+ ];
758
+ var ResourceNotFoundException = [
759
+ -3,
760
+ n0,
761
+ _RNFE,
762
+ {
763
+ [_e]: _c,
764
+ [_hE]: 404,
765
+ },
766
+ [_m, _rI, _rT],
767
+ [0, 0, 0],
768
+ ];
769
+ schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
770
+ var ScalingConfiguration = [3, n0, _SC, 0, [_mIC, _mICa], [1, 1]];
771
+ var ScalingConfigurationRequest = [3, n0, _SCR, 0, [_mIC, _mICa], [1, 1]];
772
+ var Scheduler = [3, n0, _S, 0, [_ty, _v], [0, 0]];
773
+ var SchedulerRequest = [3, n0, _SR, 0, [_ty, _v], [0, 0]];
774
+ var ServiceQuotaExceededException = [
775
+ -3,
776
+ n0,
777
+ _SQEE,
778
+ {
779
+ [_e]: _c,
780
+ [_hE]: 402,
781
+ },
782
+ [_m, _sCe, _rI, _rT, _qC],
783
+ [0, 0, 0, 0, 0],
784
+ ];
785
+ schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
786
+ var SlurmAuthKey = [3, n0, _SAK, 0, [_sA, _sV], [0, 0]];
787
+ var SlurmCustomSetting = [3, n0, _SCS, 0, [_pN, _pV], [0, 0]];
788
+ var SpotOptions = [3, n0, _SO, 0, [_aS], [0]];
789
+ var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _t], [0, 128 | 0]];
790
+ var ThrottlingException = [
791
+ -3,
792
+ n0,
793
+ _TE,
794
+ {
795
+ [_e]: _c,
796
+ [_hE]: 429,
797
+ },
798
+ [_m, _rAS],
799
+ [
800
+ 0,
801
+ [
802
+ 1,
803
+ {
804
+ [_hH]: _RA,
805
+ },
806
+ ],
807
+ ],
808
+ ];
809
+ schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
810
+ var UntagResourceRequest = [3, n0, _URR, 0, [_rA, _tK], [[0, 1], 64 | 0]];
811
+ var UpdateAccountingRequest = [3, n0, _UAR, 0, [_dPTID, _mo], [1, 0]];
812
+ var UpdateClusterRequest = [
813
+ 3,
814
+ n0,
815
+ _UCR,
816
+ 0,
817
+ [_cIl, _cT, _sC],
818
+ [0, [0, 4], () => UpdateClusterSlurmConfigurationRequest],
819
+ ];
820
+ var UpdateClusterResponse = [3, n0, _UCRp, 0, [_cl], [() => Cluster]];
821
+ var UpdateClusterSlurmConfigurationRequest = [
822
+ 3,
823
+ n0,
824
+ _UCSCR,
825
+ 0,
826
+ [_sDITIS, _sCS, _ac],
827
+ [1, () => SlurmCustomSettings, () => UpdateAccountingRequest],
828
+ ];
829
+ var UpdateComputeNodeGroupRequest = [
830
+ 3,
831
+ n0,
832
+ _UCNGR,
833
+ 0,
834
+ [_cIl, _cNGIo, _aI, _sI, _cLT, _pO, _sO, _sCc, _iIPA, _sC, _cT],
835
+ [
836
+ 0,
837
+ 0,
838
+ 0,
839
+ 64 | 0,
840
+ () => CustomLaunchTemplate,
841
+ 0,
842
+ () => SpotOptions,
843
+ () => ScalingConfigurationRequest,
844
+ 0,
845
+ () => UpdateComputeNodeGroupSlurmConfigurationRequest,
846
+ [0, 4],
847
+ ],
848
+ ];
849
+ var UpdateComputeNodeGroupResponse = [
850
+ 3,
851
+ n0,
852
+ _UCNGRp,
853
+ 0,
854
+ [_cNG],
855
+ [() => ComputeNodeGroup],
856
+ ];
857
+ var UpdateComputeNodeGroupSlurmConfigurationRequest = [
858
+ 3,
859
+ n0,
860
+ _UCNGSCR,
861
+ 0,
862
+ [_sCS],
863
+ [() => SlurmCustomSettings],
864
+ ];
865
+ var UpdateQueueRequest = [
866
+ 3,
867
+ n0,
868
+ _UQR,
869
+ 0,
870
+ [_cIl, _qI, _cNGC, _sC, _cT],
871
+ [0, 0, () => ComputeNodeGroupConfigurationList, () => UpdateQueueSlurmConfigurationRequest, [0, 4]],
872
+ ];
873
+ var UpdateQueueResponse = [3, n0, _UQRp, 0, [_q], [() => Queue]];
874
+ var UpdateQueueSlurmConfigurationRequest = [
875
+ 3,
876
+ n0,
877
+ _UQSCR,
878
+ 0,
879
+ [_sCS],
880
+ [() => SlurmCustomSettings],
881
+ ];
882
+ var ValidationException = [
883
+ -3,
884
+ n0,
885
+ _VE,
886
+ {
887
+ [_e]: _c,
888
+ [_hE]: 400,
889
+ },
890
+ [_m, _r, _fL],
891
+ [0, 0, () => ValidationExceptionFieldList],
892
+ ];
893
+ schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
894
+ var ValidationExceptionField = [3, n0, _VEF, 0, [_n, _m], [0, 0]];
895
+ var __Unit = "unit";
896
+ var PCSServiceException = [-3, _sm, "PCSServiceException", 0, [], []];
897
+ schema.TypeRegistry.for(_sm).registerError(PCSServiceException, PCSServiceException$1);
898
+ var ClusterList = [1, n0, _CL, 0, () => ClusterSummary];
899
+ var ComputeNodeGroupConfigurationList = [
900
+ 1,
901
+ n0,
902
+ _CNGCL,
903
+ 0,
904
+ () => ComputeNodeGroupConfiguration,
905
+ ];
906
+ var ComputeNodeGroupList = [1, n0, _CNGL, 0, () => ComputeNodeGroupSummary];
907
+ var Endpoints = [1, n0, _En, 0, () => Endpoint];
908
+ var ErrorInfoList = [1, n0, _EIL, 0, () => ErrorInfo];
909
+ var InstanceList = [1, n0, _IL, 0, () => InstanceConfig];
910
+ var QueueList = [1, n0, _QL, 0, () => QueueSummary];
911
+ var SlurmCustomSettings = [1, n0, _SCSl, 0, () => SlurmCustomSetting];
912
+ var ValidationExceptionFieldList = [1, n0, _VEFL, 0, () => ValidationExceptionField];
913
+ var CreateCluster = [
914
+ 9,
915
+ n0,
916
+ _CC,
917
+ 2,
918
+ () => CreateClusterRequest,
919
+ () => CreateClusterResponse,
920
+ ];
921
+ var CreateComputeNodeGroup = [
922
+ 9,
923
+ n0,
924
+ _CCNG,
925
+ 2,
926
+ () => CreateComputeNodeGroupRequest,
927
+ () => CreateComputeNodeGroupResponse,
928
+ ];
929
+ var CreateQueue = [9, n0, _CQ, 2, () => CreateQueueRequest, () => CreateQueueResponse];
930
+ var DeleteCluster = [
931
+ 9,
932
+ n0,
933
+ _DC,
934
+ 2,
935
+ () => DeleteClusterRequest,
936
+ () => DeleteClusterResponse,
937
+ ];
938
+ var DeleteComputeNodeGroup = [
939
+ 9,
940
+ n0,
941
+ _DCNG,
942
+ 2,
943
+ () => DeleteComputeNodeGroupRequest,
944
+ () => DeleteComputeNodeGroupResponse,
945
+ ];
946
+ var DeleteQueue = [9, n0, _DQ, 2, () => DeleteQueueRequest, () => DeleteQueueResponse];
947
+ var GetCluster = [9, n0, _GC, 0, () => GetClusterRequest, () => GetClusterResponse];
948
+ var GetComputeNodeGroup = [
949
+ 9,
950
+ n0,
951
+ _GCNG,
952
+ 0,
953
+ () => GetComputeNodeGroupRequest,
954
+ () => GetComputeNodeGroupResponse,
955
+ ];
956
+ var GetQueue = [9, n0, _GQ, 0, () => GetQueueRequest, () => GetQueueResponse];
957
+ var ListClusters = [9, n0, _LC, 0, () => ListClustersRequest, () => ListClustersResponse];
958
+ var ListComputeNodeGroups = [
959
+ 9,
960
+ n0,
961
+ _LCNG,
962
+ 0,
963
+ () => ListComputeNodeGroupsRequest,
964
+ () => ListComputeNodeGroupsResponse,
965
+ ];
966
+ var ListQueues = [9, n0, _LQ, 0, () => ListQueuesRequest, () => ListQueuesResponse];
967
+ var ListTagsForResource = [
968
+ 9,
969
+ n0,
970
+ _LTFR,
971
+ 0,
972
+ () => ListTagsForResourceRequest,
973
+ () => ListTagsForResourceResponse,
974
+ ];
975
+ var RegisterComputeNodeGroupInstance = [
976
+ 9,
977
+ n0,
978
+ _RCNGI,
979
+ 0,
980
+ () => RegisterComputeNodeGroupInstanceRequest,
981
+ () => RegisterComputeNodeGroupInstanceResponse,
982
+ ];
983
+ var TagResource = [9, n0, _TR, 2, () => TagResourceRequest, () => __Unit];
984
+ var UntagResource = [9, n0, _UR, 2, () => UntagResourceRequest, () => __Unit];
985
+ var UpdateCluster = [
986
+ 9,
987
+ n0,
988
+ _UC,
989
+ 2,
990
+ () => UpdateClusterRequest,
991
+ () => UpdateClusterResponse,
992
+ ];
993
+ var UpdateComputeNodeGroup = [
994
+ 9,
995
+ n0,
996
+ _UCNG,
997
+ 2,
998
+ () => UpdateComputeNodeGroupRequest,
999
+ () => UpdateComputeNodeGroupResponse,
1000
+ ];
1001
+ var UpdateQueue = [9, n0, _UQ, 2, () => UpdateQueueRequest, () => UpdateQueueResponse];
1046
1002
 
1047
1003
  class CreateClusterCommand extends smithyClient.Command
1048
1004
  .classBuilder()
1049
1005
  .ep(commonParams)
1050
1006
  .m(function (Command, cs, config, o) {
1051
- return [
1052
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1053
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1054
- ];
1007
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1055
1008
  })
1056
1009
  .s("AWSParallelComputingService", "CreateCluster", {})
1057
1010
  .n("PCSClient", "CreateClusterCommand")
1058
- .f(void 0, void 0)
1059
- .ser(se_CreateClusterCommand)
1060
- .de(de_CreateClusterCommand)
1011
+ .sc(CreateCluster)
1061
1012
  .build() {
1062
1013
  }
1063
1014
 
@@ -1065,16 +1016,11 @@ class CreateComputeNodeGroupCommand extends smithyClient.Command
1065
1016
  .classBuilder()
1066
1017
  .ep(commonParams)
1067
1018
  .m(function (Command, cs, config, o) {
1068
- return [
1069
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1070
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1071
- ];
1019
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1072
1020
  })
1073
1021
  .s("AWSParallelComputingService", "CreateComputeNodeGroup", {})
1074
1022
  .n("PCSClient", "CreateComputeNodeGroupCommand")
1075
- .f(void 0, void 0)
1076
- .ser(se_CreateComputeNodeGroupCommand)
1077
- .de(de_CreateComputeNodeGroupCommand)
1023
+ .sc(CreateComputeNodeGroup)
1078
1024
  .build() {
1079
1025
  }
1080
1026
 
@@ -1082,16 +1028,11 @@ class CreateQueueCommand extends smithyClient.Command
1082
1028
  .classBuilder()
1083
1029
  .ep(commonParams)
1084
1030
  .m(function (Command, cs, config, o) {
1085
- return [
1086
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1087
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1088
- ];
1031
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1089
1032
  })
1090
1033
  .s("AWSParallelComputingService", "CreateQueue", {})
1091
1034
  .n("PCSClient", "CreateQueueCommand")
1092
- .f(void 0, void 0)
1093
- .ser(se_CreateQueueCommand)
1094
- .de(de_CreateQueueCommand)
1035
+ .sc(CreateQueue)
1095
1036
  .build() {
1096
1037
  }
1097
1038
 
@@ -1099,16 +1040,11 @@ class DeleteClusterCommand extends smithyClient.Command
1099
1040
  .classBuilder()
1100
1041
  .ep(commonParams)
1101
1042
  .m(function (Command, cs, config, o) {
1102
- return [
1103
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1104
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1105
- ];
1043
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1106
1044
  })
1107
1045
  .s("AWSParallelComputingService", "DeleteCluster", {})
1108
1046
  .n("PCSClient", "DeleteClusterCommand")
1109
- .f(void 0, void 0)
1110
- .ser(se_DeleteClusterCommand)
1111
- .de(de_DeleteClusterCommand)
1047
+ .sc(DeleteCluster)
1112
1048
  .build() {
1113
1049
  }
1114
1050
 
@@ -1116,16 +1052,11 @@ class DeleteComputeNodeGroupCommand extends smithyClient.Command
1116
1052
  .classBuilder()
1117
1053
  .ep(commonParams)
1118
1054
  .m(function (Command, cs, config, o) {
1119
- return [
1120
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1121
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1122
- ];
1055
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1123
1056
  })
1124
1057
  .s("AWSParallelComputingService", "DeleteComputeNodeGroup", {})
1125
1058
  .n("PCSClient", "DeleteComputeNodeGroupCommand")
1126
- .f(void 0, void 0)
1127
- .ser(se_DeleteComputeNodeGroupCommand)
1128
- .de(de_DeleteComputeNodeGroupCommand)
1059
+ .sc(DeleteComputeNodeGroup)
1129
1060
  .build() {
1130
1061
  }
1131
1062
 
@@ -1133,16 +1064,11 @@ class DeleteQueueCommand extends smithyClient.Command
1133
1064
  .classBuilder()
1134
1065
  .ep(commonParams)
1135
1066
  .m(function (Command, cs, config, o) {
1136
- return [
1137
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1138
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1139
- ];
1067
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1140
1068
  })
1141
1069
  .s("AWSParallelComputingService", "DeleteQueue", {})
1142
1070
  .n("PCSClient", "DeleteQueueCommand")
1143
- .f(void 0, void 0)
1144
- .ser(se_DeleteQueueCommand)
1145
- .de(de_DeleteQueueCommand)
1071
+ .sc(DeleteQueue)
1146
1072
  .build() {
1147
1073
  }
1148
1074
 
@@ -1150,16 +1076,11 @@ class GetClusterCommand extends smithyClient.Command
1150
1076
  .classBuilder()
1151
1077
  .ep(commonParams)
1152
1078
  .m(function (Command, cs, config, o) {
1153
- return [
1154
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1155
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1156
- ];
1079
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1157
1080
  })
1158
1081
  .s("AWSParallelComputingService", "GetCluster", {})
1159
1082
  .n("PCSClient", "GetClusterCommand")
1160
- .f(void 0, void 0)
1161
- .ser(se_GetClusterCommand)
1162
- .de(de_GetClusterCommand)
1083
+ .sc(GetCluster)
1163
1084
  .build() {
1164
1085
  }
1165
1086
 
@@ -1167,16 +1088,11 @@ class GetComputeNodeGroupCommand extends smithyClient.Command
1167
1088
  .classBuilder()
1168
1089
  .ep(commonParams)
1169
1090
  .m(function (Command, cs, config, o) {
1170
- return [
1171
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1172
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1173
- ];
1091
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1174
1092
  })
1175
1093
  .s("AWSParallelComputingService", "GetComputeNodeGroup", {})
1176
1094
  .n("PCSClient", "GetComputeNodeGroupCommand")
1177
- .f(void 0, void 0)
1178
- .ser(se_GetComputeNodeGroupCommand)
1179
- .de(de_GetComputeNodeGroupCommand)
1095
+ .sc(GetComputeNodeGroup)
1180
1096
  .build() {
1181
1097
  }
1182
1098
 
@@ -1184,16 +1100,11 @@ class GetQueueCommand extends smithyClient.Command
1184
1100
  .classBuilder()
1185
1101
  .ep(commonParams)
1186
1102
  .m(function (Command, cs, config, o) {
1187
- return [
1188
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1189
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1190
- ];
1103
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1191
1104
  })
1192
1105
  .s("AWSParallelComputingService", "GetQueue", {})
1193
1106
  .n("PCSClient", "GetQueueCommand")
1194
- .f(void 0, void 0)
1195
- .ser(se_GetQueueCommand)
1196
- .de(de_GetQueueCommand)
1107
+ .sc(GetQueue)
1197
1108
  .build() {
1198
1109
  }
1199
1110
 
@@ -1201,16 +1112,11 @@ class ListClustersCommand extends smithyClient.Command
1201
1112
  .classBuilder()
1202
1113
  .ep(commonParams)
1203
1114
  .m(function (Command, cs, config, o) {
1204
- return [
1205
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1206
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1207
- ];
1115
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1208
1116
  })
1209
1117
  .s("AWSParallelComputingService", "ListClusters", {})
1210
1118
  .n("PCSClient", "ListClustersCommand")
1211
- .f(void 0, void 0)
1212
- .ser(se_ListClustersCommand)
1213
- .de(de_ListClustersCommand)
1119
+ .sc(ListClusters)
1214
1120
  .build() {
1215
1121
  }
1216
1122
 
@@ -1218,16 +1124,11 @@ class ListComputeNodeGroupsCommand extends smithyClient.Command
1218
1124
  .classBuilder()
1219
1125
  .ep(commonParams)
1220
1126
  .m(function (Command, cs, config, o) {
1221
- return [
1222
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1223
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1224
- ];
1127
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1225
1128
  })
1226
1129
  .s("AWSParallelComputingService", "ListComputeNodeGroups", {})
1227
1130
  .n("PCSClient", "ListComputeNodeGroupsCommand")
1228
- .f(void 0, void 0)
1229
- .ser(se_ListComputeNodeGroupsCommand)
1230
- .de(de_ListComputeNodeGroupsCommand)
1131
+ .sc(ListComputeNodeGroups)
1231
1132
  .build() {
1232
1133
  }
1233
1134
 
@@ -1235,16 +1136,11 @@ class ListQueuesCommand extends smithyClient.Command
1235
1136
  .classBuilder()
1236
1137
  .ep(commonParams)
1237
1138
  .m(function (Command, cs, config, o) {
1238
- return [
1239
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1240
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1241
- ];
1139
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1242
1140
  })
1243
1141
  .s("AWSParallelComputingService", "ListQueues", {})
1244
1142
  .n("PCSClient", "ListQueuesCommand")
1245
- .f(void 0, void 0)
1246
- .ser(se_ListQueuesCommand)
1247
- .de(de_ListQueuesCommand)
1143
+ .sc(ListQueues)
1248
1144
  .build() {
1249
1145
  }
1250
1146
 
@@ -1252,16 +1148,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
1252
1148
  .classBuilder()
1253
1149
  .ep(commonParams)
1254
1150
  .m(function (Command, cs, config, o) {
1255
- return [
1256
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1257
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1258
- ];
1151
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1259
1152
  })
1260
1153
  .s("AWSParallelComputingService", "ListTagsForResource", {})
1261
1154
  .n("PCSClient", "ListTagsForResourceCommand")
1262
- .f(void 0, void 0)
1263
- .ser(se_ListTagsForResourceCommand)
1264
- .de(de_ListTagsForResourceCommand)
1155
+ .sc(ListTagsForResource)
1265
1156
  .build() {
1266
1157
  }
1267
1158
 
@@ -1269,16 +1160,11 @@ class RegisterComputeNodeGroupInstanceCommand extends smithyClient.Command
1269
1160
  .classBuilder()
1270
1161
  .ep(commonParams)
1271
1162
  .m(function (Command, cs, config, o) {
1272
- return [
1273
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1274
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1275
- ];
1163
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1276
1164
  })
1277
1165
  .s("AWSParallelComputingService", "RegisterComputeNodeGroupInstance", {})
1278
1166
  .n("PCSClient", "RegisterComputeNodeGroupInstanceCommand")
1279
- .f(void 0, RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog)
1280
- .ser(se_RegisterComputeNodeGroupInstanceCommand)
1281
- .de(de_RegisterComputeNodeGroupInstanceCommand)
1167
+ .sc(RegisterComputeNodeGroupInstance)
1282
1168
  .build() {
1283
1169
  }
1284
1170
 
@@ -1286,16 +1172,11 @@ class TagResourceCommand extends smithyClient.Command
1286
1172
  .classBuilder()
1287
1173
  .ep(commonParams)
1288
1174
  .m(function (Command, cs, config, o) {
1289
- return [
1290
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1291
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1292
- ];
1175
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1293
1176
  })
1294
1177
  .s("AWSParallelComputingService", "TagResource", {})
1295
1178
  .n("PCSClient", "TagResourceCommand")
1296
- .f(void 0, void 0)
1297
- .ser(se_TagResourceCommand)
1298
- .de(de_TagResourceCommand)
1179
+ .sc(TagResource)
1299
1180
  .build() {
1300
1181
  }
1301
1182
 
@@ -1303,16 +1184,11 @@ class UntagResourceCommand extends smithyClient.Command
1303
1184
  .classBuilder()
1304
1185
  .ep(commonParams)
1305
1186
  .m(function (Command, cs, config, o) {
1306
- return [
1307
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1308
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1309
- ];
1187
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1310
1188
  })
1311
1189
  .s("AWSParallelComputingService", "UntagResource", {})
1312
1190
  .n("PCSClient", "UntagResourceCommand")
1313
- .f(void 0, void 0)
1314
- .ser(se_UntagResourceCommand)
1315
- .de(de_UntagResourceCommand)
1191
+ .sc(UntagResource)
1316
1192
  .build() {
1317
1193
  }
1318
1194
 
@@ -1320,16 +1196,11 @@ class UpdateClusterCommand extends smithyClient.Command
1320
1196
  .classBuilder()
1321
1197
  .ep(commonParams)
1322
1198
  .m(function (Command, cs, config, o) {
1323
- return [
1324
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1325
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1326
- ];
1199
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1327
1200
  })
1328
1201
  .s("AWSParallelComputingService", "UpdateCluster", {})
1329
1202
  .n("PCSClient", "UpdateClusterCommand")
1330
- .f(void 0, void 0)
1331
- .ser(se_UpdateClusterCommand)
1332
- .de(de_UpdateClusterCommand)
1203
+ .sc(UpdateCluster)
1333
1204
  .build() {
1334
1205
  }
1335
1206
 
@@ -1337,16 +1208,11 @@ class UpdateComputeNodeGroupCommand extends smithyClient.Command
1337
1208
  .classBuilder()
1338
1209
  .ep(commonParams)
1339
1210
  .m(function (Command, cs, config, o) {
1340
- return [
1341
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1342
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1343
- ];
1211
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1344
1212
  })
1345
1213
  .s("AWSParallelComputingService", "UpdateComputeNodeGroup", {})
1346
1214
  .n("PCSClient", "UpdateComputeNodeGroupCommand")
1347
- .f(void 0, void 0)
1348
- .ser(se_UpdateComputeNodeGroupCommand)
1349
- .de(de_UpdateComputeNodeGroupCommand)
1215
+ .sc(UpdateComputeNodeGroup)
1350
1216
  .build() {
1351
1217
  }
1352
1218
 
@@ -1354,16 +1220,11 @@ class UpdateQueueCommand extends smithyClient.Command
1354
1220
  .classBuilder()
1355
1221
  .ep(commonParams)
1356
1222
  .m(function (Command, cs, config, o) {
1357
- return [
1358
- middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1359
- middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1360
- ];
1223
+ return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
1361
1224
  })
1362
1225
  .s("AWSParallelComputingService", "UpdateQueue", {})
1363
1226
  .n("PCSClient", "UpdateQueueCommand")
1364
- .f(void 0, void 0)
1365
- .ser(se_UpdateQueueCommand)
1366
- .de(de_UpdateQueueCommand)
1227
+ .sc(UpdateQueue)
1367
1228
  .build() {
1368
1229
  }
1369
1230
 
@@ -1406,11 +1267,11 @@ Object.defineProperty(exports, "__Client", {
1406
1267
  enumerable: true,
1407
1268
  get: function () { return smithyClient.Client; }
1408
1269
  });
1409
- exports.AccessDeniedException = AccessDeniedException;
1270
+ exports.AccessDeniedException = AccessDeniedException$1;
1410
1271
  exports.AccountingMode = AccountingMode;
1411
1272
  exports.ClusterStatus = ClusterStatus;
1412
1273
  exports.ComputeNodeGroupStatus = ComputeNodeGroupStatus;
1413
- exports.ConflictException = ConflictException;
1274
+ exports.ConflictException = ConflictException$1;
1414
1275
  exports.CreateClusterCommand = CreateClusterCommand;
1415
1276
  exports.CreateComputeNodeGroupCommand = CreateComputeNodeGroupCommand;
1416
1277
  exports.CreateQueueCommand = CreateQueueCommand;
@@ -1421,7 +1282,7 @@ exports.EndpointType = EndpointType;
1421
1282
  exports.GetClusterCommand = GetClusterCommand;
1422
1283
  exports.GetComputeNodeGroupCommand = GetComputeNodeGroupCommand;
1423
1284
  exports.GetQueueCommand = GetQueueCommand;
1424
- exports.InternalServerException = InternalServerException;
1285
+ exports.InternalServerException = InternalServerException$1;
1425
1286
  exports.ListClustersCommand = ListClustersCommand;
1426
1287
  exports.ListComputeNodeGroupsCommand = ListComputeNodeGroupsCommand;
1427
1288
  exports.ListQueuesCommand = ListQueuesCommand;
@@ -1429,23 +1290,22 @@ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
1429
1290
  exports.NetworkType = NetworkType;
1430
1291
  exports.PCS = PCS;
1431
1292
  exports.PCSClient = PCSClient;
1432
- exports.PCSServiceException = PCSServiceException;
1293
+ exports.PCSServiceException = PCSServiceException$1;
1433
1294
  exports.PurchaseOption = PurchaseOption;
1434
1295
  exports.QueueStatus = QueueStatus;
1435
1296
  exports.RegisterComputeNodeGroupInstanceCommand = RegisterComputeNodeGroupInstanceCommand;
1436
- exports.RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog = RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog;
1437
- exports.ResourceNotFoundException = ResourceNotFoundException;
1297
+ exports.ResourceNotFoundException = ResourceNotFoundException$1;
1438
1298
  exports.SchedulerType = SchedulerType;
1439
- exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
1299
+ exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
1440
1300
  exports.Size = Size;
1441
1301
  exports.SpotAllocationStrategy = SpotAllocationStrategy;
1442
1302
  exports.TagResourceCommand = TagResourceCommand;
1443
- exports.ThrottlingException = ThrottlingException;
1303
+ exports.ThrottlingException = ThrottlingException$1;
1444
1304
  exports.UntagResourceCommand = UntagResourceCommand;
1445
1305
  exports.UpdateClusterCommand = UpdateClusterCommand;
1446
1306
  exports.UpdateComputeNodeGroupCommand = UpdateComputeNodeGroupCommand;
1447
1307
  exports.UpdateQueueCommand = UpdateQueueCommand;
1448
- exports.ValidationException = ValidationException;
1308
+ exports.ValidationException = ValidationException$1;
1449
1309
  exports.ValidationExceptionReason = ValidationExceptionReason;
1450
1310
  exports.paginateListClusters = paginateListClusters;
1451
1311
  exports.paginateListComputeNodeGroups = paginateListComputeNodeGroups;