@aws-sdk/client-sso-oidc 3.928.0 → 3.930.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,8 +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');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class SSOOIDCClient 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));
@@ -110,17 +110,17 @@ class SSOOIDCClient extends smithyClient.Client {
     }
 }
 
-class SSOOIDCServiceException extends smithyClient.ServiceException {
+let SSOOIDCServiceException$1 = class SSOOIDCServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SSOOIDCServiceException.prototype);
     }
-}
+};
 
 const AccessDeniedExceptionReason = {
     KMS_ACCESS_DENIED: "KMS_AccessDeniedException",
 };
-class AccessDeniedException extends SSOOIDCServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends SSOOIDCServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     error;
@@ -137,8 +137,8 @@ class AccessDeniedException extends SSOOIDCServiceException {
         this.reason = opts.reason;
         this.error_description = opts.error_description;
     }
-}
-class AuthorizationPendingException extends SSOOIDCServiceException {
+};
+let AuthorizationPendingException$1 = class AuthorizationPendingException extends SSOOIDCServiceException$1 {
     name = "AuthorizationPendingException";
     $fault = "client";
     error;
@@ -153,8 +153,8 @@ class AuthorizationPendingException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class ExpiredTokenException extends SSOOIDCServiceException {
+};
+let ExpiredTokenException$1 = class ExpiredTokenException extends SSOOIDCServiceException$1 {
     name = "ExpiredTokenException";
     $fault = "client";
     error;
@@ -169,8 +169,8 @@ class ExpiredTokenException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class InternalServerException extends SSOOIDCServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends SSOOIDCServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     error;
@@ -185,8 +185,8 @@ class InternalServerException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class InvalidClientException extends SSOOIDCServiceException {
+};
+let InvalidClientException$1 = class InvalidClientException extends SSOOIDCServiceException$1 {
     name = "InvalidClientException";
     $fault = "client";
     error;
@@ -201,8 +201,8 @@ class InvalidClientException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class InvalidGrantException extends SSOOIDCServiceException {
+};
+let InvalidGrantException$1 = class InvalidGrantException extends SSOOIDCServiceException$1 {
     name = "InvalidGrantException";
     $fault = "client";
     error;
@@ -217,14 +217,14 @@ class InvalidGrantException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
+};
 const InvalidRequestExceptionReason = {
     KMS_DISABLED_KEY: "KMS_DisabledException",
     KMS_INVALID_KEY_USAGE: "KMS_InvalidKeyUsageException",
     KMS_INVALID_STATE: "KMS_InvalidStateException",
     KMS_KEY_NOT_FOUND: "KMS_NotFoundException",
 };
-class InvalidRequestException extends SSOOIDCServiceException {
+let InvalidRequestException$1 = class InvalidRequestException extends SSOOIDCServiceException$1 {
     name = "InvalidRequestException";
     $fault = "client";
     error;
@@ -241,8 +241,8 @@ class InvalidRequestException extends SSOOIDCServiceException {
         this.reason = opts.reason;
         this.error_description = opts.error_description;
     }
-}
-class InvalidScopeException extends SSOOIDCServiceException {
+};
+let InvalidScopeException$1 = class InvalidScopeException extends SSOOIDCServiceException$1 {
     name = "InvalidScopeException";
     $fault = "client";
     error;
@@ -257,8 +257,8 @@ class InvalidScopeException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class SlowDownException extends SSOOIDCServiceException {
+};
+let SlowDownException$1 = class SlowDownException extends SSOOIDCServiceException$1 {
     name = "SlowDownException";
     $fault = "client";
     error;
@@ -273,8 +273,8 @@ class SlowDownException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class UnauthorizedClientException extends SSOOIDCServiceException {
+};
+let UnauthorizedClientException$1 = class UnauthorizedClientException extends SSOOIDCServiceException$1 {
     name = "UnauthorizedClientException";
     $fault = "client";
     error;
@@ -289,8 +289,8 @@ class UnauthorizedClientException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class UnsupportedGrantTypeException extends SSOOIDCServiceException {
+};
+let UnsupportedGrantTypeException$1 = class UnsupportedGrantTypeException extends SSOOIDCServiceException$1 {
     name = "UnsupportedGrantTypeException";
     $fault = "client";
     error;
@@ -305,8 +305,8 @@ class UnsupportedGrantTypeException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class InvalidRequestRegionException extends SSOOIDCServiceException {
+};
+let InvalidRequestRegionException$1 = class InvalidRequestRegionException extends SSOOIDCServiceException$1 {
     name = "InvalidRequestRegionException";
     $fault = "client";
     error;
@@ -325,8 +325,8 @@ class InvalidRequestRegionException extends SSOOIDCServiceException {
         this.endpoint = opts.endpoint;
         this.region = opts.region;
     }
-}
-class InvalidClientMetadataException extends SSOOIDCServiceException {
+};
+let InvalidClientMetadataException$1 = class InvalidClientMetadataException extends SSOOIDCServiceException$1 {
     name = "InvalidClientMetadataException";
     $fault = "client";
     error;
@@ -341,8 +341,8 @@ class InvalidClientMetadataException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-class InvalidRedirectUriException extends SSOOIDCServiceException {
+};
+let InvalidRedirectUriException$1 = class InvalidRedirectUriException extends SSOOIDCServiceException$1 {
     name = "InvalidRedirectUriException";
     $fault = "client";
     error;
@@ -357,480 +357,393 @@ class InvalidRedirectUriException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-const CreateTokenRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-    ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.codeVerifier && { codeVerifier: smithyClient.SENSITIVE_STRING }),
-});
-const CreateTokenResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.idToken && { idToken: smithyClient.SENSITIVE_STRING }),
-});
-const CreateTokenWithIAMRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.assertion && { assertion: smithyClient.SENSITIVE_STRING }),
-    ...(obj.subjectToken && { subjectToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.codeVerifier && { codeVerifier: smithyClient.SENSITIVE_STRING }),
-});
-const CreateTokenWithIAMResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.idToken && { idToken: smithyClient.SENSITIVE_STRING }),
-});
-const RegisterClientResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-});
-const StartDeviceAuthorizationRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
-});
-
-const se_CreateTokenCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/token");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientId: [],
-        clientSecret: [],
-        code: [],
-        codeVerifier: [],
-        deviceCode: [],
-        grantType: [],
-        redirectUri: [],
-        refreshToken: [],
-        scope: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
 };
-const se_CreateTokenWithIAMCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/token");
-    const query = smithyClient.map({
-        [_ai]: [, "t"],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        assertion: [],
-        clientId: [],
-        code: [],
-        codeVerifier: [],
-        grantType: [],
-        redirectUri: [],
-        refreshToken: [],
-        requestedTokenType: [],
-        scope: (_) => smithyClient._json(_),
-        subjectToken: [],
-        subjectTokenType: [],
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_RegisterClientCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/client/register");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientName: [],
-        clientType: [],
-        entitledApplicationArn: [],
-        grantTypes: (_) => smithyClient._json(_),
-        issuerUrl: [],
-        redirectUris: (_) => smithyClient._json(_),
-        scopes: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartDeviceAuthorizationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/device_authorization");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientId: [],
-        clientSecret: [],
-        startUrl: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CreateTokenCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        accessToken: smithyClient.expectString,
-        expiresIn: smithyClient.expectInt32,
-        idToken: smithyClient.expectString,
-        refreshToken: smithyClient.expectString,
-        tokenType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateTokenWithIAMCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        accessToken: smithyClient.expectString,
-        awsAdditionalDetails: smithyClient._json,
-        expiresIn: smithyClient.expectInt32,
-        idToken: smithyClient.expectString,
-        issuedTokenType: smithyClient.expectString,
-        refreshToken: smithyClient.expectString,
-        scope: smithyClient._json,
-        tokenType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_RegisterClientCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        authorizationEndpoint: smithyClient.expectString,
-        clientId: smithyClient.expectString,
-        clientIdIssuedAt: smithyClient.expectLong,
-        clientSecret: smithyClient.expectString,
-        clientSecretExpiresAt: smithyClient.expectLong,
-        tokenEndpoint: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartDeviceAuthorizationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        deviceCode: smithyClient.expectString,
-        expiresIn: smithyClient.expectInt32,
-        interval: smithyClient.expectInt32,
-        userCode: smithyClient.expectString,
-        verificationUri: smithyClient.expectString,
-        verificationUriComplete: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-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.ssooidc#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "AuthorizationPendingException":
-        case "com.amazonaws.ssooidc#AuthorizationPendingException":
-            throw await de_AuthorizationPendingExceptionRes(parsedOutput);
-        case "ExpiredTokenException":
-        case "com.amazonaws.ssooidc#ExpiredTokenException":
-            throw await de_ExpiredTokenExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.ssooidc#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "InvalidClientException":
-        case "com.amazonaws.ssooidc#InvalidClientException":
-            throw await de_InvalidClientExceptionRes(parsedOutput);
-        case "InvalidGrantException":
-        case "com.amazonaws.ssooidc#InvalidGrantException":
-            throw await de_InvalidGrantExceptionRes(parsedOutput);
-        case "InvalidRequestException":
-        case "com.amazonaws.ssooidc#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(parsedOutput);
-        case "InvalidScopeException":
-        case "com.amazonaws.ssooidc#InvalidScopeException":
-            throw await de_InvalidScopeExceptionRes(parsedOutput);
-        case "SlowDownException":
-        case "com.amazonaws.ssooidc#SlowDownException":
-            throw await de_SlowDownExceptionRes(parsedOutput);
-        case "UnauthorizedClientException":
-        case "com.amazonaws.ssooidc#UnauthorizedClientException":
-            throw await de_UnauthorizedClientExceptionRes(parsedOutput);
-        case "UnsupportedGrantTypeException":
-        case "com.amazonaws.ssooidc#UnsupportedGrantTypeException":
-            throw await de_UnsupportedGrantTypeExceptionRes(parsedOutput);
-        case "InvalidRequestRegionException":
-        case "com.amazonaws.ssooidc#InvalidRequestRegionException":
-            throw await de_InvalidRequestRegionExceptionRes(parsedOutput);
-        case "InvalidClientMetadataException":
-        case "com.amazonaws.ssooidc#InvalidClientMetadataException":
-            throw await de_InvalidClientMetadataExceptionRes(parsedOutput);
-        case "InvalidRedirectUriException":
-        case "com.amazonaws.ssooidc#InvalidRedirectUriException":
-            throw await de_InvalidRedirectUriExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(SSOOIDCServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-        reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_AuthorizationPendingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AuthorizationPendingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ExpiredTokenExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ExpiredTokenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidClientExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidClientException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidClientMetadataExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidClientMetadataException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidGrantExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidGrantException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidRedirectUriExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidRedirectUriException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-        reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidRequestRegionExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        endpoint: smithyClient.expectString,
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-        region: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidRequestRegionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidScopeExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InvalidScopeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_SlowDownExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new SlowDownException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_UnauthorizedClientExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new UnauthorizedClientException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_UnsupportedGrantTypeExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        error: smithyClient.expectString,
-        error_description: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new UnsupportedGrantTypeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-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 _ai = "aws_iam";
+
+const _A = "Assertion";
+const _AAD = "AwsAdditionalDetails";
+const _ADE = "AccessDeniedException";
+const _APE = "AuthorizationPendingException";
+const _AT = "AccessToken";
+const _CS = "ClientSecret";
+const _CT = "CreateToken";
+const _CTR = "CreateTokenRequest";
+const _CTRr = "CreateTokenResponse";
+const _CTWIAM = "CreateTokenWithIAM";
+const _CTWIAMR = "CreateTokenWithIAMRequest";
+const _CTWIAMRr = "CreateTokenWithIAMResponse";
+const _CV = "CodeVerifier";
+const _ETE = "ExpiredTokenException";
+const _ICE = "InvalidClientException";
+const _ICME = "InvalidClientMetadataException";
+const _IGE = "InvalidGrantException";
+const _IRE = "InvalidRequestException";
+const _IRRE = "InvalidRequestRegionException";
+const _IRUE = "InvalidRedirectUriException";
+const _ISE = "InternalServerException";
+const _ISEn = "InvalidScopeException";
+const _IT = "IdToken";
+const _RC = "RegisterClient";
+const _RCR = "RegisterClientRequest";
+const _RCRe = "RegisterClientResponse";
+const _RT = "RefreshToken";
+const _SDA = "StartDeviceAuthorization";
+const _SDAR = "StartDeviceAuthorizationRequest";
+const _SDARt = "StartDeviceAuthorizationResponse";
+const _SDE = "SlowDownException";
+const _ST = "SubjectToken";
+const _UCE = "UnauthorizedClientException";
+const _UGTE = "UnsupportedGrantTypeException";
+const _a = "assertion";
+const _aAD = "awsAdditionalDetails";
+const _aE = "authorizationEndpoint";
+const _aT = "accessToken";
+const _c = "client";
+const _cI = "clientId";
+const _cIIA = "clientIdIssuedAt";
+const _cN = "clientName";
+const _cS = "clientSecret";
+const _cSEA = "clientSecretExpiresAt";
+const _cT = "clientType";
+const _cV = "codeVerifier";
+const _co = "code";
+const _dC = "deviceCode";
+const _e = "error";
+const _eAA = "entitledApplicationArn";
+const _eI = "expiresIn";
+const _ed = "error_description";
+const _en = "endpoint";
+const _gT = "grantType";
+const _gTr = "grantTypes";
+const _h = "http";
+const _hE = "httpError";
+const _i = "interval";
+const _iC = "identityContext";
+const _iT = "idToken";
+const _iTT = "issuedTokenType";
+const _iU = "issuerUrl";
+const _r = "reason";
+const _rT = "refreshToken";
+const _rTT = "requestedTokenType";
+const _rU = "redirectUri";
+const _rUe = "redirectUris";
+const _re = "region";
+const _s = "scope";
+const _sT = "subjectToken";
+const _sTT = "subjectTokenType";
+const _sU = "startUrl";
+const _sc = "scopes";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ssooidc";
+const _tE = "tokenEndpoint";
+const _tT = "tokenType";
+const _uC = "userCode";
+const _vU = "verificationUri";
+const _vUC = "verificationUriComplete";
+const n0 = "com.amazonaws.ssooidc";
+var AccessToken = [0, n0, _AT, 8, 0];
+var Assertion = [0, n0, _A, 8, 0];
+var ClientSecret = [0, n0, _CS, 8, 0];
+var CodeVerifier = [0, n0, _CV, 8, 0];
+var IdToken = [0, n0, _IT, 8, 0];
+var RefreshToken = [0, n0, _RT, 8, 0];
+var SubjectToken = [0, n0, _ST, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _r, _ed],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AuthorizationPendingException = [
+    -3,
+    n0,
+    _APE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(AuthorizationPendingException, AuthorizationPendingException$1);
+var AwsAdditionalDetails = [3, n0, _AAD, 0, [_iC], [0]];
+var CreateTokenRequest = [
+    3,
+    n0,
+    _CTR,
+    0,
+    [_cI, _cS, _gT, _dC, _co, _rT, _s, _rU, _cV],
+    [0, [() => ClientSecret, 0], 0, 0, 0, [() => RefreshToken, 0], 64 | 0, 0, [() => CodeVerifier, 0]],
+];
+var CreateTokenResponse = [
+    3,
+    n0,
+    _CTRr,
+    0,
+    [_aT, _tT, _eI, _rT, _iT],
+    [[() => AccessToken, 0], 0, 1, [() => RefreshToken, 0], [() => IdToken, 0]],
+];
+var CreateTokenWithIAMRequest = [
+    3,
+    n0,
+    _CTWIAMR,
+    0,
+    [_cI, _gT, _co, _rT, _a, _s, _rU, _sT, _sTT, _rTT, _cV],
+    [
+        0,
+        0,
+        0,
+        [() => RefreshToken, 0],
+        [() => Assertion, 0],
+        64 | 0,
+        0,
+        [() => SubjectToken, 0],
+        0,
+        0,
+        [() => CodeVerifier, 0],
+    ],
+];
+var CreateTokenWithIAMResponse = [
+    3,
+    n0,
+    _CTWIAMRr,
+    0,
+    [_aT, _tT, _eI, _rT, _iT, _iTT, _s, _aAD],
+    [[() => AccessToken, 0], 0, 1, [() => RefreshToken, 0], [() => IdToken, 0], 0, 64 | 0, () => AwsAdditionalDetails],
+];
+var ExpiredTokenException = [
+    -3,
+    n0,
+    _ETE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ExpiredTokenException, ExpiredTokenException$1);
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var InvalidClientException = [
+    -3,
+    n0,
+    _ICE,
+    {
+        [_e]: _c,
+        [_hE]: 401,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidClientException, InvalidClientException$1);
+var InvalidClientMetadataException = [
+    -3,
+    n0,
+    _ICME,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidClientMetadataException, InvalidClientMetadataException$1);
+var InvalidGrantException = [
+    -3,
+    n0,
+    _IGE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidGrantException, InvalidGrantException$1);
+var InvalidRedirectUriException = [
+    -3,
+    n0,
+    _IRUE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRedirectUriException, InvalidRedirectUriException$1);
+var InvalidRequestException = [
+    -3,
+    n0,
+    _IRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _r, _ed],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRequestException, InvalidRequestException$1);
+var InvalidRequestRegionException = [
+    -3,
+    n0,
+    _IRRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed, _en, _re],
+    [0, 0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRequestRegionException, InvalidRequestRegionException$1);
+var InvalidScopeException = [
+    -3,
+    n0,
+    _ISEn,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidScopeException, InvalidScopeException$1);
+var RegisterClientRequest = [
+    3,
+    n0,
+    _RCR,
+    0,
+    [_cN, _cT, _sc, _rUe, _gTr, _iU, _eAA],
+    [0, 0, 64 | 0, 64 | 0, 64 | 0, 0, 0],
+];
+var RegisterClientResponse = [
+    3,
+    n0,
+    _RCRe,
+    0,
+    [_cI, _cS, _cIIA, _cSEA, _aE, _tE],
+    [0, [() => ClientSecret, 0], 1, 1, 0, 0],
+];
+var SlowDownException = [
+    -3,
+    n0,
+    _SDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(SlowDownException, SlowDownException$1);
+var StartDeviceAuthorizationRequest = [
+    3,
+    n0,
+    _SDAR,
+    0,
+    [_cI, _cS, _sU],
+    [0, [() => ClientSecret, 0], 0],
+];
+var StartDeviceAuthorizationResponse = [
+    3,
+    n0,
+    _SDARt,
+    0,
+    [_dC, _uC, _vU, _vUC, _eI, _i],
+    [0, 0, 0, 0, 1, 1],
+];
+var UnauthorizedClientException = [
+    -3,
+    n0,
+    _UCE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(UnauthorizedClientException, UnauthorizedClientException$1);
+var UnsupportedGrantTypeException = [
+    -3,
+    n0,
+    _UGTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedGrantTypeException, UnsupportedGrantTypeException$1);
+var SSOOIDCServiceException = [-3, _sm, "SSOOIDCServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(SSOOIDCServiceException, SSOOIDCServiceException$1);
+var CreateToken = [
+    9,
+    n0,
+    _CT,
+    {
+        [_h]: ["POST", "/token", 200],
+    },
+    () => CreateTokenRequest,
+    () => CreateTokenResponse,
+];
+var CreateTokenWithIAM = [
+    9,
+    n0,
+    _CTWIAM,
+    {
+        [_h]: ["POST", "/token?aws_iam=t", 200],
+    },
+    () => CreateTokenWithIAMRequest,
+    () => CreateTokenWithIAMResponse,
+];
+var RegisterClient = [
+    9,
+    n0,
+    _RC,
+    {
+        [_h]: ["POST", "/client/register", 200],
+    },
+    () => RegisterClientRequest,
+    () => RegisterClientResponse,
+];
+var StartDeviceAuthorization = [
+    9,
+    n0,
+    _SDA,
+    {
+        [_h]: ["POST", "/device_authorization", 200],
+    },
+    () => StartDeviceAuthorizationRequest,
+    () => StartDeviceAuthorizationResponse,
+];
 
 class CreateTokenCommand 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("AWSSSOOIDCService", "CreateToken", {})
     .n("SSOOIDCClient", "CreateTokenCommand")
-    .f(CreateTokenRequestFilterSensitiveLog, CreateTokenResponseFilterSensitiveLog)
-    .ser(se_CreateTokenCommand)
-    .de(de_CreateTokenCommand)
+    .sc(CreateToken)
     .build() {
 }
 
@@ -838,16 +751,11 @@ class CreateTokenWithIAMCommand 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("AWSSSOOIDCService", "CreateTokenWithIAM", {})
     .n("SSOOIDCClient", "CreateTokenWithIAMCommand")
-    .f(CreateTokenWithIAMRequestFilterSensitiveLog, CreateTokenWithIAMResponseFilterSensitiveLog)
-    .ser(se_CreateTokenWithIAMCommand)
-    .de(de_CreateTokenWithIAMCommand)
+    .sc(CreateTokenWithIAM)
     .build() {
 }
 
@@ -855,16 +763,11 @@ class RegisterClientCommand 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("AWSSSOOIDCService", "RegisterClient", {})
     .n("SSOOIDCClient", "RegisterClientCommand")
-    .f(void 0, RegisterClientResponseFilterSensitiveLog)
-    .ser(se_RegisterClientCommand)
-    .de(de_RegisterClientCommand)
+    .sc(RegisterClient)
     .build() {
 }
 
@@ -872,16 +775,11 @@ class StartDeviceAuthorizationCommand 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("AWSSSOOIDCService", "StartDeviceAuthorization", {})
     .n("SSOOIDCClient", "StartDeviceAuthorizationCommand")
-    .f(StartDeviceAuthorizationRequestFilterSensitiveLog, void 0)
-    .ser(se_StartDeviceAuthorizationCommand)
-    .de(de_StartDeviceAuthorizationCommand)
+    .sc(StartDeviceAuthorization)
     .build() {
 }
 
@@ -903,32 +801,26 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AccessDeniedExceptionReason = AccessDeniedExceptionReason;
-exports.AuthorizationPendingException = AuthorizationPendingException;
+exports.AuthorizationPendingException = AuthorizationPendingException$1;
 exports.CreateTokenCommand = CreateTokenCommand;
-exports.CreateTokenRequestFilterSensitiveLog = CreateTokenRequestFilterSensitiveLog;
-exports.CreateTokenResponseFilterSensitiveLog = CreateTokenResponseFilterSensitiveLog;
 exports.CreateTokenWithIAMCommand = CreateTokenWithIAMCommand;
-exports.CreateTokenWithIAMRequestFilterSensitiveLog = CreateTokenWithIAMRequestFilterSensitiveLog;
-exports.CreateTokenWithIAMResponseFilterSensitiveLog = CreateTokenWithIAMResponseFilterSensitiveLog;
-exports.ExpiredTokenException = ExpiredTokenException;
-exports.InternalServerException = InternalServerException;
-exports.InvalidClientException = InvalidClientException;
-exports.InvalidClientMetadataException = InvalidClientMetadataException;
-exports.InvalidGrantException = InvalidGrantException;
-exports.InvalidRedirectUriException = InvalidRedirectUriException;
-exports.InvalidRequestException = InvalidRequestException;
+exports.ExpiredTokenException = ExpiredTokenException$1;
+exports.InternalServerException = InternalServerException$1;
+exports.InvalidClientException = InvalidClientException$1;
+exports.InvalidClientMetadataException = InvalidClientMetadataException$1;
+exports.InvalidGrantException = InvalidGrantException$1;
+exports.InvalidRedirectUriException = InvalidRedirectUriException$1;
+exports.InvalidRequestException = InvalidRequestException$1;
 exports.InvalidRequestExceptionReason = InvalidRequestExceptionReason;
-exports.InvalidRequestRegionException = InvalidRequestRegionException;
-exports.InvalidScopeException = InvalidScopeException;
+exports.InvalidRequestRegionException = InvalidRequestRegionException$1;
+exports.InvalidScopeException = InvalidScopeException$1;
 exports.RegisterClientCommand = RegisterClientCommand;
-exports.RegisterClientResponseFilterSensitiveLog = RegisterClientResponseFilterSensitiveLog;
 exports.SSOOIDC = SSOOIDC;
 exports.SSOOIDCClient = SSOOIDCClient;
-exports.SSOOIDCServiceException = SSOOIDCServiceException;
-exports.SlowDownException = SlowDownException;
+exports.SSOOIDCServiceException = SSOOIDCServiceException$1;
+exports.SlowDownException = SlowDownException$1;
 exports.StartDeviceAuthorizationCommand = StartDeviceAuthorizationCommand;
-exports.StartDeviceAuthorizationRequestFilterSensitiveLog = StartDeviceAuthorizationRequestFilterSensitiveLog;
-exports.UnauthorizedClientException = UnauthorizedClientException;
-exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException;
+exports.UnauthorizedClientException = UnauthorizedClientException$1;
+exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException$1;