@aws-sdk/client-pcs 3.926.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class PCSClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class PCSClient extends smithyClient.Client {
     }
 }
 
-class PCSServiceException extends smithyClient.ServiceException {
+let PCSServiceException$1 = class PCSServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, PCSServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends PCSServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends PCSServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -129,12 +128,12 @@ class AccessDeniedException extends PCSServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const AccountingMode = {
     NONE: "NONE",
     STANDARD: "STANDARD",
 };
-class ConflictException extends PCSServiceException {
+let ConflictException$1 = class ConflictException extends PCSServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     resourceId;
@@ -149,7 +148,7 @@ class ConflictException extends PCSServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
+};
 const PurchaseOption = {
     CAPACITY_BLOCK: "CAPACITY_BLOCK",
     ONDEMAND: "ONDEMAND",
@@ -172,7 +171,7 @@ const ComputeNodeGroupStatus = {
     UPDATE_FAILED: "UPDATE_FAILED",
     UPDATING: "UPDATING",
 };
-class InternalServerException extends PCSServiceException {
+let InternalServerException$1 = class InternalServerException extends PCSServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -184,8 +183,8 @@ class InternalServerException extends PCSServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends PCSServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends PCSServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     resourceId;
@@ -200,8 +199,8 @@ class ResourceNotFoundException extends PCSServiceException {
         this.resourceId = opts.resourceId;
         this.resourceType = opts.resourceType;
     }
-}
-class ServiceQuotaExceededException extends PCSServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends PCSServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     serviceCode;
@@ -220,8 +219,8 @@ class ServiceQuotaExceededException extends PCSServiceException {
         this.resourceType = opts.resourceType;
         this.quotaCode = opts.quotaCode;
     }
-}
-class ThrottlingException extends PCSServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends PCSServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {};
@@ -235,14 +234,14 @@ class ThrottlingException extends PCSServiceException {
         Object.setPrototypeOf(this, ThrottlingException.prototype);
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
+};
 const ValidationExceptionReason = {
     CANNOT_PARSE: "cannotParse",
     FIELD_VALIDATION_FAILED: "fieldValidationFailed",
     OTHER: "other",
     UNKNOWN_OPERATION: "unknownOperation",
 };
-class ValidationException extends PCSServiceException {
+let ValidationException$1 = class ValidationException extends PCSServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     reason;
@@ -257,7 +256,7 @@ class ValidationException extends PCSServiceException {
         this.reason = opts.reason;
         this.fieldList = opts.fieldList;
     }
-}
+};
 const NetworkType = {
     IPV4: "IPV4",
     IPV6: "IPV6",
@@ -296,768 +295,720 @@ const QueueStatus = {
     UPDATE_FAILED: "UPDATE_FAILED",
     UPDATING: "UPDATING",
 };
-const RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.sharedSecret && { sharedSecret: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_CreateClusterCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateCluster");
-    let body;
-    body = JSON.stringify(se_CreateClusterRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateComputeNodeGroupCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateComputeNodeGroup");
-    let body;
-    body = JSON.stringify(se_CreateComputeNodeGroupRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateQueueCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateQueue");
-    let body;
-    body = JSON.stringify(se_CreateQueueRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteClusterCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteCluster");
-    let body;
-    body = JSON.stringify(se_DeleteClusterRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteComputeNodeGroupCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteComputeNodeGroup");
-    let body;
-    body = JSON.stringify(se_DeleteComputeNodeGroupRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteQueueCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteQueue");
-    let body;
-    body = JSON.stringify(se_DeleteQueueRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetClusterCommand = async (input, context) => {
-    const headers = sharedHeaders("GetCluster");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetComputeNodeGroupCommand = async (input, context) => {
-    const headers = sharedHeaders("GetComputeNodeGroup");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetQueueCommand = async (input, context) => {
-    const headers = sharedHeaders("GetQueue");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListClustersCommand = async (input, context) => {
-    const headers = sharedHeaders("ListClusters");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListComputeNodeGroupsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListComputeNodeGroups");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListQueuesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListQueues");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterComputeNodeGroupInstanceCommand = async (input, context) => {
-    const headers = sharedHeaders("RegisterComputeNodeGroupInstance");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateClusterCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateCluster");
-    let body;
-    body = JSON.stringify(se_UpdateClusterRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateComputeNodeGroupCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateComputeNodeGroup");
-    let body;
-    body = JSON.stringify(se_UpdateComputeNodeGroupRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateQueueCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateQueue");
-    let body;
-    body = JSON.stringify(se_UpdateQueueRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CreateClusterCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateClusterResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateComputeNodeGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateComputeNodeGroupResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateQueueResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteClusterCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteComputeNodeGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetClusterCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetClusterResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetComputeNodeGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetComputeNodeGroupResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetQueueResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListClustersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListClustersResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListComputeNodeGroupsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListComputeNodeGroupsResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListQueuesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListQueuesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RegisterComputeNodeGroupInstanceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UpdateClusterCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateClusterResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateComputeNodeGroupCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateComputeNodeGroupResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateQueueCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateQueueResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.pcs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.pcs#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.pcs#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.pcs#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.pcs#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.pcs#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.pcs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_CreateClusterRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterName: [],
-        networking: smithyClient._json,
-        scheduler: smithyClient._json,
-        size: [],
-        slurmConfiguration: smithyClient._json,
-        tags: smithyClient._json,
-    });
-};
-const se_CreateComputeNodeGroupRequest = (input, context) => {
-    return smithyClient.take(input, {
-        amiId: [],
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        computeNodeGroupName: [],
-        customLaunchTemplate: smithyClient._json,
-        iamInstanceProfileArn: [],
-        instanceConfigs: smithyClient._json,
-        purchaseOption: [],
-        scalingConfiguration: smithyClient._json,
-        slurmConfiguration: smithyClient._json,
-        spotOptions: smithyClient._json,
-        subnetIds: smithyClient._json,
-        tags: smithyClient._json,
-    });
-};
-const se_CreateQueueRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        computeNodeGroupConfigurations: smithyClient._json,
-        queueName: [],
-        slurmConfiguration: smithyClient._json,
-        tags: smithyClient._json,
-    });
-};
-const se_DeleteClusterRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-    });
-};
-const se_DeleteComputeNodeGroupRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        computeNodeGroupIdentifier: [],
-    });
-};
-const se_DeleteQueueRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        queueIdentifier: [],
-    });
-};
-const se_UpdateClusterRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        slurmConfiguration: smithyClient._json,
-    });
-};
-const se_UpdateComputeNodeGroupRequest = (input, context) => {
-    return smithyClient.take(input, {
-        amiId: [],
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        computeNodeGroupIdentifier: [],
-        customLaunchTemplate: smithyClient._json,
-        iamInstanceProfileArn: [],
-        purchaseOption: [],
-        scalingConfiguration: smithyClient._json,
-        slurmConfiguration: smithyClient._json,
-        spotOptions: smithyClient._json,
-        subnetIds: smithyClient._json,
-    });
-};
-const se_UpdateQueueRequest = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        clusterIdentifier: [],
-        computeNodeGroupConfigurations: smithyClient._json,
-        queueIdentifier: [],
-        slurmConfiguration: smithyClient._json,
-    });
-};
-const de_Cluster = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        endpoints: smithyClient._json,
-        errorInfo: smithyClient._json,
-        id: smithyClient.expectString,
-        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        networking: smithyClient._json,
-        scheduler: smithyClient._json,
-        size: smithyClient.expectString,
-        slurmConfiguration: smithyClient._json,
-        status: smithyClient.expectString,
-    });
-};
-const de_ClusterList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ClusterSummary(entry);
-    });
-    return retVal;
-};
-const de_ClusterSummary = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        id: smithyClient.expectString,
-        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        status: smithyClient.expectString,
-    });
-};
-const de_ComputeNodeGroup = (output, context) => {
-    return smithyClient.take(output, {
-        amiId: smithyClient.expectString,
-        arn: smithyClient.expectString,
-        clusterId: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        customLaunchTemplate: smithyClient._json,
-        errorInfo: smithyClient._json,
-        iamInstanceProfileArn: smithyClient.expectString,
-        id: smithyClient.expectString,
-        instanceConfigs: smithyClient._json,
-        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        purchaseOption: smithyClient.expectString,
-        scalingConfiguration: smithyClient._json,
-        slurmConfiguration: smithyClient._json,
-        spotOptions: smithyClient._json,
-        status: smithyClient.expectString,
-        subnetIds: smithyClient._json,
-    });
-};
-const de_ComputeNodeGroupList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ComputeNodeGroupSummary(entry);
-    });
-    return retVal;
-};
-const de_ComputeNodeGroupSummary = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        clusterId: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        id: smithyClient.expectString,
-        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        status: smithyClient.expectString,
-    });
-};
-const de_CreateClusterResponse = (output, context) => {
-    return smithyClient.take(output, {
-        cluster: (_) => de_Cluster(_),
-    });
-};
-const de_CreateComputeNodeGroupResponse = (output, context) => {
-    return smithyClient.take(output, {
-        computeNodeGroup: (_) => de_ComputeNodeGroup(_),
-    });
-};
-const de_CreateQueueResponse = (output, context) => {
-    return smithyClient.take(output, {
-        queue: (_) => de_Queue(_),
-    });
-};
-const de_GetClusterResponse = (output, context) => {
-    return smithyClient.take(output, {
-        cluster: (_) => de_Cluster(_),
-    });
-};
-const de_GetComputeNodeGroupResponse = (output, context) => {
-    return smithyClient.take(output, {
-        computeNodeGroup: (_) => de_ComputeNodeGroup(_),
-    });
-};
-const de_GetQueueResponse = (output, context) => {
-    return smithyClient.take(output, {
-        queue: (_) => de_Queue(_),
-    });
-};
-const de_ListClustersResponse = (output, context) => {
-    return smithyClient.take(output, {
-        clusters: (_) => de_ClusterList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListComputeNodeGroupsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        computeNodeGroups: (_) => de_ComputeNodeGroupList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListQueuesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        queues: (_) => de_QueueList(_),
-    });
-};
-const de_Queue = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        clusterId: smithyClient.expectString,
-        computeNodeGroupConfigurations: smithyClient._json,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        errorInfo: smithyClient._json,
-        id: smithyClient.expectString,
-        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        slurmConfiguration: smithyClient._json,
-        status: smithyClient.expectString,
-    });
-};
-const de_QueueList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_QueueSummary(entry);
-    });
-    return retVal;
-};
-const de_QueueSummary = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        clusterId: smithyClient.expectString,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        id: smithyClient.expectString,
-        modifiedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        name: smithyClient.expectString,
-        status: smithyClient.expectString,
-    });
-};
-const de_UpdateClusterResponse = (output, context) => {
-    return smithyClient.take(output, {
-        cluster: (_) => de_Cluster(_),
-    });
-};
-const de_UpdateComputeNodeGroupResponse = (output, context) => {
-    return smithyClient.take(output, {
-        computeNodeGroup: (_) => de_ComputeNodeGroup(_),
-    });
-};
-const de_UpdateQueueResponse = (output, context) => {
-    return smithyClient.take(output, {
-        queue: (_) => de_Queue(_),
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(PCSServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": `AWSParallelComputingService.${operation}`,
-    };
-}
+const _A = "Accounting";
+const _ADE = "AccessDeniedException";
+const _AR = "AccountingRequest";
+const _C = "Cluster";
+const _CC = "CreateCluster";
+const _CCNG = "CreateComputeNodeGroup";
+const _CCNGR = "CreateComputeNodeGroupRequest";
+const _CCNGRr = "CreateComputeNodeGroupResponse";
+const _CCR = "CreateClusterRequest";
+const _CCRr = "CreateClusterResponse";
+const _CE = "ConflictException";
+const _CL = "ClusterList";
+const _CLT = "CustomLaunchTemplate";
+const _CNG = "ComputeNodeGroup";
+const _CNGC = "ComputeNodeGroupConfiguration";
+const _CNGCL = "ComputeNodeGroupConfigurationList";
+const _CNGL = "ComputeNodeGroupList";
+const _CNGS = "ComputeNodeGroupSummary";
+const _CNGSC = "ComputeNodeGroupSlurmConfiguration";
+const _CNGSCR = "ComputeNodeGroupSlurmConfigurationRequest";
+const _CQ = "CreateQueue";
+const _CQR = "CreateQueueRequest";
+const _CQRr = "CreateQueueResponse";
+const _CS = "ClusterSummary";
+const _CSC = "ClusterSlurmConfiguration";
+const _CSCR = "ClusterSlurmConfigurationRequest";
+const _DC = "DeleteCluster";
+const _DCNG = "DeleteComputeNodeGroup";
+const _DCNGR = "DeleteComputeNodeGroupRequest";
+const _DCNGRe = "DeleteComputeNodeGroupResponse";
+const _DCR = "DeleteClusterRequest";
+const _DCRe = "DeleteClusterResponse";
+const _DQ = "DeleteQueue";
+const _DQR = "DeleteQueueRequest";
+const _DQRe = "DeleteQueueResponse";
+const _E = "Endpoint";
+const _EI = "ErrorInfo";
+const _EIL = "ErrorInfoList";
+const _En = "Endpoints";
+const _GC = "GetCluster";
+const _GCNG = "GetComputeNodeGroup";
+const _GCNGR = "GetComputeNodeGroupRequest";
+const _GCNGRe = "GetComputeNodeGroupResponse";
+const _GCR = "GetClusterRequest";
+const _GCRe = "GetClusterResponse";
+const _GQ = "GetQueue";
+const _GQR = "GetQueueRequest";
+const _GQRe = "GetQueueResponse";
+const _IC = "InstanceConfig";
+const _IL = "InstanceList";
+const _ISE = "InternalServerException";
+const _LC = "ListClusters";
+const _LCNG = "ListComputeNodeGroups";
+const _LCNGR = "ListComputeNodeGroupsRequest";
+const _LCNGRi = "ListComputeNodeGroupsResponse";
+const _LCR = "ListClustersRequest";
+const _LCRi = "ListClustersResponse";
+const _LQ = "ListQueues";
+const _LQR = "ListQueuesRequest";
+const _LQRi = "ListQueuesResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _N = "Networking";
+const _NR = "NetworkingRequest";
+const _Q = "Queue";
+const _QL = "QueueList";
+const _QS = "QueueSummary";
+const _QSC = "QueueSlurmConfiguration";
+const _QSCR = "QueueSlurmConfigurationRequest";
+const _RA = "Retry-After";
+const _RCNGI = "RegisterComputeNodeGroupInstance";
+const _RCNGIR = "RegisterComputeNodeGroupInstanceRequest";
+const _RCNGIRe = "RegisterComputeNodeGroupInstanceResponse";
+const _RNFE = "ResourceNotFoundException";
+const _S = "Scheduler";
+const _SAK = "SlurmAuthKey";
+const _SC = "ScalingConfiguration";
+const _SCR = "ScalingConfigurationRequest";
+const _SCS = "SlurmCustomSetting";
+const _SCSl = "SlurmCustomSettings";
+const _SO = "SpotOptions";
+const _SQEE = "ServiceQuotaExceededException";
+const _SR = "SchedulerRequest";
+const _SS = "SharedSecret";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _UAR = "UpdateAccountingRequest";
+const _UC = "UpdateCluster";
+const _UCNG = "UpdateComputeNodeGroup";
+const _UCNGR = "UpdateComputeNodeGroupRequest";
+const _UCNGRp = "UpdateComputeNodeGroupResponse";
+const _UCNGSCR = "UpdateComputeNodeGroupSlurmConfigurationRequest";
+const _UCR = "UpdateClusterRequest";
+const _UCRp = "UpdateClusterResponse";
+const _UCSCR = "UpdateClusterSlurmConfigurationRequest";
+const _UQ = "UpdateQueue";
+const _UQR = "UpdateQueueRequest";
+const _UQRp = "UpdateQueueResponse";
+const _UQSCR = "UpdateQueueSlurmConfigurationRequest";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _a = "arn";
+const _aI = "amiId";
+const _aK = "authKey";
+const _aS = "allocationStrategy";
+const _ac = "accounting";
+const _bI = "bootstrapId";
+const _c = "client";
+const _cA = "createdAt";
+const _cI = "clusterId";
+const _cIl = "clusterIdentifier";
+const _cLT = "customLaunchTemplate";
+const _cN = "clusterName";
+const _cNG = "computeNodeGroup";
+const _cNGC = "computeNodeGroupConfigurations";
+const _cNGI = "computeNodeGroupId";
+const _cNGIo = "computeNodeGroupIdentifier";
+const _cNGN = "computeNodeGroupName";
+const _cNGo = "computeNodeGroups";
+const _cT = "clientToken";
+const _cl = "cluster";
+const _clu = "clusters";
+const _co = "code";
+const _dPTID = "defaultPurgeTimeInDays";
+const _e = "error";
+const _eI = "errorInfo";
+const _en = "endpoints";
+const _fL = "fieldList";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _i = "id";
+const _iA = "ipv6Address";
+const _iC = "instanceConfigs";
+const _iIPA = "iamInstanceProfileArn";
+const _iT = "instanceType";
+const _m = "message";
+const _mA = "modifiedAt";
+const _mIC = "minInstanceCount";
+const _mICa = "maxInstanceCount";
+const _mR = "maxResults";
+const _mo = "mode";
+const _n = "name";
+const _nID = "nodeID";
+const _nT = "nextToken";
+const _nTe = "networkType";
+const _ne = "networking";
+const _p = "port";
+const _pIA = "privateIpAddress";
+const _pIAu = "publicIpAddress";
+const _pN = "parameterName";
+const _pO = "purchaseOption";
+const _pV = "parameterValue";
+const _q = "queue";
+const _qC = "quotaCode";
+const _qI = "queueIdentifier";
+const _qN = "queueName";
+const _qu = "queues";
+const _r = "reason";
+const _rA = "resourceArn";
+const _rAS = "retryAfterSeconds";
+const _rI = "resourceId";
+const _rT = "resourceType";
+const _s = "status";
+const _sA = "secretArn";
+const _sC = "slurmConfiguration";
+const _sCS = "slurmCustomSettings";
+const _sCc = "scalingConfiguration";
+const _sCe = "serviceCode";
+const _sDITIS = "scaleDownIdleTimeInSeconds";
+const _sGI = "securityGroupIds";
+const _sI = "subnetIds";
+const _sO = "spotOptions";
+const _sS = "sharedSecret";
+const _sV = "secretVersion";
+const _sc = "scheduler";
+const _se = "server";
+const _si = "size";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.pcs";
+const _t = "tags";
+const _tK = "tagKeys";
+const _ty = "type";
+const _v = "version";
+const n0 = "com.amazonaws.pcs";
+var SharedSecret = [0, n0, _SS, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var Accounting = [3, n0, _A, 0, [_dPTID, _mo], [1, 0]];
+var AccountingRequest = [3, n0, _AR, 0, [_dPTID, _mo], [1, 0]];
+var Cluster = [
+    3,
+    n0,
+    _C,
+    0,
+    [_n, _i, _a, _s, _cA, _mA, _sc, _si, _sC, _ne, _en, _eI],
+    [
+        0,
+        0,
+        0,
+        0,
+        5,
+        5,
+        () => Scheduler,
+        0,
+        () => ClusterSlurmConfiguration,
+        () => Networking,
+        () => Endpoints,
+        () => ErrorInfoList,
+    ],
+];
+var ClusterSlurmConfiguration = [
+    3,
+    n0,
+    _CSC,
+    0,
+    [_sDITIS, _sCS, _aK, _ac],
+    [1, () => SlurmCustomSettings, () => SlurmAuthKey, () => Accounting],
+];
+var ClusterSlurmConfigurationRequest = [
+    3,
+    n0,
+    _CSCR,
+    0,
+    [_sDITIS, _sCS, _ac],
+    [1, () => SlurmCustomSettings, () => AccountingRequest],
+];
+var ClusterSummary = [3, n0, _CS, 0, [_n, _i, _a, _cA, _mA, _s], [0, 0, 0, 5, 5, 0]];
+var ComputeNodeGroup = [
+    3,
+    n0,
+    _CNG,
+    0,
+    [_n, _i, _a, _cI, _cA, _mA, _s, _aI, _sI, _pO, _cLT, _iIPA, _sCc, _iC, _sO, _sC, _eI],
+    [
+        0,
+        0,
+        0,
+        0,
+        5,
+        5,
+        0,
+        0,
+        64 | 0,
+        0,
+        () => CustomLaunchTemplate,
+        0,
+        () => ScalingConfiguration,
+        () => InstanceList,
+        () => SpotOptions,
+        () => ComputeNodeGroupSlurmConfiguration,
+        () => ErrorInfoList,
+    ],
+];
+var ComputeNodeGroupConfiguration = [3, n0, _CNGC, 0, [_cNGI], [0]];
+var ComputeNodeGroupSlurmConfiguration = [
+    3,
+    n0,
+    _CNGSC,
+    0,
+    [_sCS],
+    [() => SlurmCustomSettings],
+];
+var ComputeNodeGroupSlurmConfigurationRequest = [
+    3,
+    n0,
+    _CNGSCR,
+    0,
+    [_sCS],
+    [() => SlurmCustomSettings],
+];
+var ComputeNodeGroupSummary = [
+    3,
+    n0,
+    _CNGS,
+    0,
+    [_n, _i, _a, _cI, _cA, _mA, _s],
+    [0, 0, 0, 0, 5, 5, 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m, _rI, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateClusterRequest = [
+    3,
+    n0,
+    _CCR,
+    0,
+    [_cN, _sc, _si, _ne, _sC, _cT, _t],
+    [0, () => SchedulerRequest, 0, () => NetworkingRequest, () => ClusterSlurmConfigurationRequest, [0, 4], 128 | 0],
+];
+var CreateClusterResponse = [3, n0, _CCRr, 0, [_cl], [() => Cluster]];
+var CreateComputeNodeGroupRequest = [
+    3,
+    n0,
+    _CCNGR,
+    0,
+    [_cIl, _cNGN, _aI, _sI, _pO, _cLT, _iIPA, _sCc, _iC, _sO, _sC, _cT, _t],
+    [
+        0,
+        0,
+        0,
+        64 | 0,
+        0,
+        () => CustomLaunchTemplate,
+        0,
+        () => ScalingConfigurationRequest,
+        () => InstanceList,
+        () => SpotOptions,
+        () => ComputeNodeGroupSlurmConfigurationRequest,
+        [0, 4],
+        128 | 0,
+    ],
+];
+var CreateComputeNodeGroupResponse = [
+    3,
+    n0,
+    _CCNGRr,
+    0,
+    [_cNG],
+    [() => ComputeNodeGroup],
+];
+var CreateQueueRequest = [
+    3,
+    n0,
+    _CQR,
+    0,
+    [_cIl, _qN, _cNGC, _sC, _cT, _t],
+    [0, 0, () => ComputeNodeGroupConfigurationList, () => QueueSlurmConfigurationRequest, [0, 4], 128 | 0],
+];
+var CreateQueueResponse = [3, n0, _CQRr, 0, [_q], [() => Queue]];
+var CustomLaunchTemplate = [3, n0, _CLT, 0, [_i, _v], [0, 0]];
+var DeleteClusterRequest = [3, n0, _DCR, 0, [_cIl, _cT], [0, [0, 4]]];
+var DeleteClusterResponse = [3, n0, _DCRe, 0, [], []];
+var DeleteComputeNodeGroupRequest = [
+    3,
+    n0,
+    _DCNGR,
+    0,
+    [_cIl, _cNGIo, _cT],
+    [0, 0, [0, 4]],
+];
+var DeleteComputeNodeGroupResponse = [3, n0, _DCNGRe, 0, [], []];
+var DeleteQueueRequest = [3, n0, _DQR, 0, [_cIl, _qI, _cT], [0, 0, [0, 4]]];
+var DeleteQueueResponse = [3, n0, _DQRe, 0, [], []];
+var Endpoint = [3, n0, _E, 0, [_ty, _pIA, _pIAu, _iA, _p], [0, 0, 0, 0, 0]];
+var ErrorInfo = [3, n0, _EI, 0, [_co, _m], [0, 0]];
+var GetClusterRequest = [3, n0, _GCR, 0, [_cIl], [0]];
+var GetClusterResponse = [3, n0, _GCRe, 0, [_cl], [() => Cluster]];
+var GetComputeNodeGroupRequest = [3, n0, _GCNGR, 0, [_cIl, _cNGIo], [0, 0]];
+var GetComputeNodeGroupResponse = [3, n0, _GCNGRe, 0, [_cNG], [() => ComputeNodeGroup]];
+var GetQueueRequest = [3, n0, _GQR, 0, [_cIl, _qI], [0, 0]];
+var GetQueueResponse = [3, n0, _GQRe, 0, [_q], [() => Queue]];
+var InstanceConfig = [3, n0, _IC, 0, [_iT], [0]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListClustersRequest = [
+    3,
+    n0,
+    _LCR,
+    0,
+    [_nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListClustersResponse = [3, n0, _LCRi, 0, [_clu, _nT], [() => ClusterList, 0]];
+var ListComputeNodeGroupsRequest = [3, n0, _LCNGR, 0, [_cIl, _nT, _mR], [0, 0, 1]];
+var ListComputeNodeGroupsResponse = [
+    3,
+    n0,
+    _LCNGRi,
+    0,
+    [_cNGo, _nT],
+    [() => ComputeNodeGroupList, 0],
+];
+var ListQueuesRequest = [3, n0, _LQR, 0, [_cIl, _nT, _mR], [0, 0, 1]];
+var ListQueuesResponse = [3, n0, _LQRi, 0, [_qu, _nT], [() => QueueList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [0]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [128 | 0]];
+var Networking = [3, n0, _N, 0, [_sI, _sGI, _nTe], [64 | 0, 64 | 0, 0]];
+var NetworkingRequest = [3, n0, _NR, 0, [_sI, _sGI, _nTe], [64 | 0, 64 | 0, 0]];
+var Queue = [
+    3,
+    n0,
+    _Q,
+    0,
+    [_n, _i, _a, _cI, _cA, _mA, _s, _cNGC, _sC, _eI],
+    [0, 0, 0, 0, 5, 5, 0, () => ComputeNodeGroupConfigurationList, () => QueueSlurmConfiguration, () => ErrorInfoList],
+];
+var QueueSlurmConfiguration = [3, n0, _QSC, 0, [_sCS], [() => SlurmCustomSettings]];
+var QueueSlurmConfigurationRequest = [
+    3,
+    n0,
+    _QSCR,
+    0,
+    [_sCS],
+    [() => SlurmCustomSettings],
+];
+var QueueSummary = [
+    3,
+    n0,
+    _QS,
+    0,
+    [_n, _i, _a, _cI, _cA, _mA, _s],
+    [0, 0, 0, 0, 5, 5, 0],
+];
+var RegisterComputeNodeGroupInstanceRequest = [3, n0, _RCNGIR, 0, [_cIl, _bI], [0, 0]];
+var RegisterComputeNodeGroupInstanceResponse = [
+    3,
+    n0,
+    _RCNGIRe,
+    0,
+    [_nID, _sS, _en],
+    [0, [() => SharedSecret, 0], () => Endpoints],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m, _rI, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ScalingConfiguration = [3, n0, _SC, 0, [_mIC, _mICa], [1, 1]];
+var ScalingConfigurationRequest = [3, n0, _SCR, 0, [_mIC, _mICa], [1, 1]];
+var Scheduler = [3, n0, _S, 0, [_ty, _v], [0, 0]];
+var SchedulerRequest = [3, n0, _SR, 0, [_ty, _v], [0, 0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m, _sCe, _rI, _rT, _qC],
+    [0, 0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var SlurmAuthKey = [3, n0, _SAK, 0, [_sA, _sV], [0, 0]];
+var SlurmCustomSetting = [3, n0, _SCS, 0, [_pN, _pV], [0, 0]];
+var SpotOptions = [3, n0, _SO, 0, [_aS], [0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _t], [0, 128 | 0]];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m, _rAS],
+    [
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [3, n0, _URR, 0, [_rA, _tK], [[0, 1], 64 | 0]];
+var UpdateAccountingRequest = [3, n0, _UAR, 0, [_dPTID, _mo], [1, 0]];
+var UpdateClusterRequest = [
+    3,
+    n0,
+    _UCR,
+    0,
+    [_cIl, _cT, _sC],
+    [0, [0, 4], () => UpdateClusterSlurmConfigurationRequest],
+];
+var UpdateClusterResponse = [3, n0, _UCRp, 0, [_cl], [() => Cluster]];
+var UpdateClusterSlurmConfigurationRequest = [
+    3,
+    n0,
+    _UCSCR,
+    0,
+    [_sDITIS, _sCS, _ac],
+    [1, () => SlurmCustomSettings, () => UpdateAccountingRequest],
+];
+var UpdateComputeNodeGroupRequest = [
+    3,
+    n0,
+    _UCNGR,
+    0,
+    [_cIl, _cNGIo, _aI, _sI, _cLT, _pO, _sO, _sCc, _iIPA, _sC, _cT],
+    [
+        0,
+        0,
+        0,
+        64 | 0,
+        () => CustomLaunchTemplate,
+        0,
+        () => SpotOptions,
+        () => ScalingConfigurationRequest,
+        0,
+        () => UpdateComputeNodeGroupSlurmConfigurationRequest,
+        [0, 4],
+    ],
+];
+var UpdateComputeNodeGroupResponse = [
+    3,
+    n0,
+    _UCNGRp,
+    0,
+    [_cNG],
+    [() => ComputeNodeGroup],
+];
+var UpdateComputeNodeGroupSlurmConfigurationRequest = [
+    3,
+    n0,
+    _UCNGSCR,
+    0,
+    [_sCS],
+    [() => SlurmCustomSettings],
+];
+var UpdateQueueRequest = [
+    3,
+    n0,
+    _UQR,
+    0,
+    [_cIl, _qI, _cNGC, _sC, _cT],
+    [0, 0, () => ComputeNodeGroupConfigurationList, () => UpdateQueueSlurmConfigurationRequest, [0, 4]],
+];
+var UpdateQueueResponse = [3, n0, _UQRp, 0, [_q], [() => Queue]];
+var UpdateQueueSlurmConfigurationRequest = [
+    3,
+    n0,
+    _UQSCR,
+    0,
+    [_sCS],
+    [() => SlurmCustomSettings],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _r, _fL],
+    [0, 0, () => ValidationExceptionFieldList],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var ValidationExceptionField = [3, n0, _VEF, 0, [_n, _m], [0, 0]];
+var __Unit = "unit";
+var PCSServiceException = [-3, _sm, "PCSServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(PCSServiceException, PCSServiceException$1);
+var ClusterList = [1, n0, _CL, 0, () => ClusterSummary];
+var ComputeNodeGroupConfigurationList = [
+    1,
+    n0,
+    _CNGCL,
+    0,
+    () => ComputeNodeGroupConfiguration,
+];
+var ComputeNodeGroupList = [1, n0, _CNGL, 0, () => ComputeNodeGroupSummary];
+var Endpoints = [1, n0, _En, 0, () => Endpoint];
+var ErrorInfoList = [1, n0, _EIL, 0, () => ErrorInfo];
+var InstanceList = [1, n0, _IL, 0, () => InstanceConfig];
+var QueueList = [1, n0, _QL, 0, () => QueueSummary];
+var SlurmCustomSettings = [1, n0, _SCSl, 0, () => SlurmCustomSetting];
+var ValidationExceptionFieldList = [1, n0, _VEFL, 0, () => ValidationExceptionField];
+var CreateCluster = [
+    9,
+    n0,
+    _CC,
+    2,
+    () => CreateClusterRequest,
+    () => CreateClusterResponse,
+];
+var CreateComputeNodeGroup = [
+    9,
+    n0,
+    _CCNG,
+    2,
+    () => CreateComputeNodeGroupRequest,
+    () => CreateComputeNodeGroupResponse,
+];
+var CreateQueue = [9, n0, _CQ, 2, () => CreateQueueRequest, () => CreateQueueResponse];
+var DeleteCluster = [
+    9,
+    n0,
+    _DC,
+    2,
+    () => DeleteClusterRequest,
+    () => DeleteClusterResponse,
+];
+var DeleteComputeNodeGroup = [
+    9,
+    n0,
+    _DCNG,
+    2,
+    () => DeleteComputeNodeGroupRequest,
+    () => DeleteComputeNodeGroupResponse,
+];
+var DeleteQueue = [9, n0, _DQ, 2, () => DeleteQueueRequest, () => DeleteQueueResponse];
+var GetCluster = [9, n0, _GC, 0, () => GetClusterRequest, () => GetClusterResponse];
+var GetComputeNodeGroup = [
+    9,
+    n0,
+    _GCNG,
+    0,
+    () => GetComputeNodeGroupRequest,
+    () => GetComputeNodeGroupResponse,
+];
+var GetQueue = [9, n0, _GQ, 0, () => GetQueueRequest, () => GetQueueResponse];
+var ListClusters = [9, n0, _LC, 0, () => ListClustersRequest, () => ListClustersResponse];
+var ListComputeNodeGroups = [
+    9,
+    n0,
+    _LCNG,
+    0,
+    () => ListComputeNodeGroupsRequest,
+    () => ListComputeNodeGroupsResponse,
+];
+var ListQueues = [9, n0, _LQ, 0, () => ListQueuesRequest, () => ListQueuesResponse];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var RegisterComputeNodeGroupInstance = [
+    9,
+    n0,
+    _RCNGI,
+    0,
+    () => RegisterComputeNodeGroupInstanceRequest,
+    () => RegisterComputeNodeGroupInstanceResponse,
+];
+var TagResource = [9, n0, _TR, 2, () => TagResourceRequest, () => __Unit];
+var UntagResource = [9, n0, _UR, 2, () => UntagResourceRequest, () => __Unit];
+var UpdateCluster = [
+    9,
+    n0,
+    _UC,
+    2,
+    () => UpdateClusterRequest,
+    () => UpdateClusterResponse,
+];
+var UpdateComputeNodeGroup = [
+    9,
+    n0,
+    _UCNG,
+    2,
+    () => UpdateComputeNodeGroupRequest,
+    () => UpdateComputeNodeGroupResponse,
+];
+var UpdateQueue = [9, n0, _UQ, 2, () => UpdateQueueRequest, () => UpdateQueueResponse];
 
 class CreateClusterCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "CreateCluster", {})
     .n("PCSClient", "CreateClusterCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateClusterCommand)
-    .de(de_CreateClusterCommand)
+    .sc(CreateCluster)
     .build() {
 }
 
@@ -1065,16 +1016,11 @@ class CreateComputeNodeGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "CreateComputeNodeGroup", {})
     .n("PCSClient", "CreateComputeNodeGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateComputeNodeGroupCommand)
-    .de(de_CreateComputeNodeGroupCommand)
+    .sc(CreateComputeNodeGroup)
     .build() {
 }
 
@@ -1082,16 +1028,11 @@ class CreateQueueCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "CreateQueue", {})
     .n("PCSClient", "CreateQueueCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateQueueCommand)
-    .de(de_CreateQueueCommand)
+    .sc(CreateQueue)
     .build() {
 }
 
@@ -1099,16 +1040,11 @@ class DeleteClusterCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "DeleteCluster", {})
     .n("PCSClient", "DeleteClusterCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteClusterCommand)
-    .de(de_DeleteClusterCommand)
+    .sc(DeleteCluster)
     .build() {
 }
 
@@ -1116,16 +1052,11 @@ class DeleteComputeNodeGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "DeleteComputeNodeGroup", {})
     .n("PCSClient", "DeleteComputeNodeGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteComputeNodeGroupCommand)
-    .de(de_DeleteComputeNodeGroupCommand)
+    .sc(DeleteComputeNodeGroup)
     .build() {
 }
 
@@ -1133,16 +1064,11 @@ class DeleteQueueCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "DeleteQueue", {})
     .n("PCSClient", "DeleteQueueCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteQueueCommand)
-    .de(de_DeleteQueueCommand)
+    .sc(DeleteQueue)
     .build() {
 }
 
@@ -1150,16 +1076,11 @@ class GetClusterCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "GetCluster", {})
     .n("PCSClient", "GetClusterCommand")
-    .f(void 0, void 0)
-    .ser(se_GetClusterCommand)
-    .de(de_GetClusterCommand)
+    .sc(GetCluster)
     .build() {
 }
 
@@ -1167,16 +1088,11 @@ class GetComputeNodeGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "GetComputeNodeGroup", {})
     .n("PCSClient", "GetComputeNodeGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_GetComputeNodeGroupCommand)
-    .de(de_GetComputeNodeGroupCommand)
+    .sc(GetComputeNodeGroup)
     .build() {
 }
 
@@ -1184,16 +1100,11 @@ class GetQueueCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "GetQueue", {})
     .n("PCSClient", "GetQueueCommand")
-    .f(void 0, void 0)
-    .ser(se_GetQueueCommand)
-    .de(de_GetQueueCommand)
+    .sc(GetQueue)
     .build() {
 }
 
@@ -1201,16 +1112,11 @@ class ListClustersCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "ListClusters", {})
     .n("PCSClient", "ListClustersCommand")
-    .f(void 0, void 0)
-    .ser(se_ListClustersCommand)
-    .de(de_ListClustersCommand)
+    .sc(ListClusters)
     .build() {
 }
 
@@ -1218,16 +1124,11 @@ class ListComputeNodeGroupsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "ListComputeNodeGroups", {})
     .n("PCSClient", "ListComputeNodeGroupsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListComputeNodeGroupsCommand)
-    .de(de_ListComputeNodeGroupsCommand)
+    .sc(ListComputeNodeGroups)
     .build() {
 }
 
@@ -1235,16 +1136,11 @@ class ListQueuesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "ListQueues", {})
     .n("PCSClient", "ListQueuesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListQueuesCommand)
-    .de(de_ListQueuesCommand)
+    .sc(ListQueues)
     .build() {
 }
 
@@ -1252,16 +1148,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "ListTagsForResource", {})
     .n("PCSClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1269,16 +1160,11 @@ class RegisterComputeNodeGroupInstanceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "RegisterComputeNodeGroupInstance", {})
     .n("PCSClient", "RegisterComputeNodeGroupInstanceCommand")
-    .f(void 0, RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog)
-    .ser(se_RegisterComputeNodeGroupInstanceCommand)
-    .de(de_RegisterComputeNodeGroupInstanceCommand)
+    .sc(RegisterComputeNodeGroupInstance)
     .build() {
 }
 
@@ -1286,16 +1172,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "TagResource", {})
     .n("PCSClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1303,16 +1184,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "UntagResource", {})
     .n("PCSClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1320,16 +1196,11 @@ class UpdateClusterCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "UpdateCluster", {})
     .n("PCSClient", "UpdateClusterCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateClusterCommand)
-    .de(de_UpdateClusterCommand)
+    .sc(UpdateCluster)
     .build() {
 }
 
@@ -1337,16 +1208,11 @@ class UpdateComputeNodeGroupCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "UpdateComputeNodeGroup", {})
     .n("PCSClient", "UpdateComputeNodeGroupCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateComputeNodeGroupCommand)
-    .de(de_UpdateComputeNodeGroupCommand)
+    .sc(UpdateComputeNodeGroup)
     .build() {
 }
 
@@ -1354,16 +1220,11 @@ class UpdateQueueCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSParallelComputingService", "UpdateQueue", {})
     .n("PCSClient", "UpdateQueueCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateQueueCommand)
-    .de(de_UpdateQueueCommand)
+    .sc(UpdateQueue)
     .build() {
 }
 
@@ -1406,11 +1267,11 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AccountingMode = AccountingMode;
 exports.ClusterStatus = ClusterStatus;
 exports.ComputeNodeGroupStatus = ComputeNodeGroupStatus;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateClusterCommand = CreateClusterCommand;
 exports.CreateComputeNodeGroupCommand = CreateComputeNodeGroupCommand;
 exports.CreateQueueCommand = CreateQueueCommand;
@@ -1421,7 +1282,7 @@ exports.EndpointType = EndpointType;
 exports.GetClusterCommand = GetClusterCommand;
 exports.GetComputeNodeGroupCommand = GetComputeNodeGroupCommand;
 exports.GetQueueCommand = GetQueueCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListClustersCommand = ListClustersCommand;
 exports.ListComputeNodeGroupsCommand = ListComputeNodeGroupsCommand;
 exports.ListQueuesCommand = ListQueuesCommand;
@@ -1429,23 +1290,22 @@ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.NetworkType = NetworkType;
 exports.PCS = PCS;
 exports.PCSClient = PCSClient;
-exports.PCSServiceException = PCSServiceException;
+exports.PCSServiceException = PCSServiceException$1;
 exports.PurchaseOption = PurchaseOption;
 exports.QueueStatus = QueueStatus;
 exports.RegisterComputeNodeGroupInstanceCommand = RegisterComputeNodeGroupInstanceCommand;
-exports.RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog = RegisterComputeNodeGroupInstanceResponseFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SchedulerType = SchedulerType;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.Size = Size;
 exports.SpotAllocationStrategy = SpotAllocationStrategy;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateClusterCommand = UpdateClusterCommand;
 exports.UpdateComputeNodeGroupCommand = UpdateComputeNodeGroupCommand;
 exports.UpdateQueueCommand = UpdateQueueCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
 exports.paginateListClusters = paginateListClusters;
 exports.paginateListComputeNodeGroups = paginateListComputeNodeGroups;