@jjrawlins/cdk-iam-policy-builder-helper 0.0.78 → 0.0.80

package/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sso-oidc/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,20 +153,8 @@ class AuthorizationPendingException 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 }),
-});
-class ExpiredTokenException extends SSOOIDCServiceException {
+};
+let ExpiredTokenException$1 = class ExpiredTokenException extends SSOOIDCServiceException$1 {
     name = "ExpiredTokenException";
     $fault = "client";
     error;
@@ -181,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;
@@ -197,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;
@@ -213,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;
@@ -229,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;
@@ -253,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;
@@ -269,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;
@@ -285,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;
@@ -301,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;
@@ -317,274 +305,224 @@ class UnsupportedGrantTypeException extends SSOOIDCServiceException {
         this.error = opts.error;
         this.error_description = opts.error_description;
     }
-}
-
-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 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_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);
-        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_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_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_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 _ADE = "AccessDeniedException";
+const _APE = "AuthorizationPendingException";
+const _AT = "AccessToken";
+const _CS = "ClientSecret";
+const _CT = "CreateToken";
+const _CTR = "CreateTokenRequest";
+const _CTRr = "CreateTokenResponse";
+const _CV = "CodeVerifier";
+const _ETE = "ExpiredTokenException";
+const _ICE = "InvalidClientException";
+const _IGE = "InvalidGrantException";
+const _IRE = "InvalidRequestException";
+const _ISE = "InternalServerException";
+const _ISEn = "InvalidScopeException";
+const _IT = "IdToken";
+const _RT = "RefreshToken";
+const _SDE = "SlowDownException";
+const _UCE = "UnauthorizedClientException";
+const _UGTE = "UnsupportedGrantTypeException";
+const _aT = "accessToken";
+const _c = "client";
+const _cI = "clientId";
+const _cS = "clientSecret";
+const _cV = "codeVerifier";
+const _co = "code";
+const _dC = "deviceCode";
+const _e = "error";
+const _eI = "expiresIn";
+const _ed = "error_description";
+const _gT = "grantType";
+const _h = "http";
+const _hE = "httpError";
+const _iT = "idToken";
+const _r = "reason";
+const _rT = "refreshToken";
+const _rU = "redirectUri";
+const _s = "scope";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ssooidc";
+const _tT = "tokenType";
+const n0 = "com.amazonaws.ssooidc";
+var AccessToken = [0, n0, _AT, 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 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 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 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 InvalidGrantException = [
+    -3,
+    n0,
+    _IGE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidGrantException, InvalidGrantException$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 InvalidScopeException = [
+    -3,
+    n0,
+    _ISEn,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidScopeException, InvalidScopeException$1);
+var SlowDownException = [
+    -3,
+    n0,
+    _SDE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_e, _ed],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(SlowDownException, SlowDownException$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,
+];
 
 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() {
 }
 
@@ -603,22 +541,20 @@ 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.ExpiredTokenException = ExpiredTokenException;
-exports.InternalServerException = InternalServerException;
-exports.InvalidClientException = InvalidClientException;
-exports.InvalidGrantException = InvalidGrantException;
-exports.InvalidRequestException = InvalidRequestException;
+exports.ExpiredTokenException = ExpiredTokenException$1;
+exports.InternalServerException = InternalServerException$1;
+exports.InvalidClientException = InvalidClientException$1;
+exports.InvalidGrantException = InvalidGrantException$1;
+exports.InvalidRequestException = InvalidRequestException$1;
 exports.InvalidRequestExceptionReason = InvalidRequestExceptionReason;
-exports.InvalidScopeException = InvalidScopeException;
+exports.InvalidScopeException = InvalidScopeException$1;
 exports.SSOOIDC = SSOOIDC;
 exports.SSOOIDCClient = SSOOIDCClient;
-exports.SSOOIDCServiceException = SSOOIDCServiceException;
-exports.SlowDownException = SlowDownException;
-exports.UnauthorizedClientException = UnauthorizedClientException;
-exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException;
+exports.SSOOIDCServiceException = SSOOIDCServiceException$1;
+exports.SlowDownException = SlowDownException$1;
+exports.UnauthorizedClientException = UnauthorizedClientException$1;
+exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException$1;