@aws-sdk/client-eks 3.183.0 → 3.186.0

package/dist-es/commands/DeleteNodegroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteNodegroupRequestFilterSensitiveLog, DeleteNodegroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteNodegroupCommand, serializeAws_restJson1DeleteNodegroupCommand, } from "../protocols/Aws_restJson1";
-export class DeleteNodegroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteNodegroupCommand = (function (_super) {
+    __extends(DeleteNodegroupCommand, _super);
+    function DeleteNodegroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteNodegroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DeleteNodegroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DeleteNodegroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteNodegroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteNodegroupResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteNodegroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteNodegroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteNodegroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteNodegroupCommand(output, context);
-    }
-}
+    };
+    return DeleteNodegroupCommand;
+}($Command));
+export { DeleteNodegroupCommand };

package/dist-es/commands/DeregisterClusterCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeregisterClusterRequestFilterSensitiveLog, DeregisterClusterResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeregisterClusterCommand, serializeAws_restJson1DeregisterClusterCommand, } from "../protocols/Aws_restJson1";
-export class DeregisterClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeregisterClusterCommand = (function (_super) {
+    __extends(DeregisterClusterCommand, _super);
+    function DeregisterClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeregisterClusterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DeregisterClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DeregisterClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeregisterClusterRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeregisterClusterResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeregisterClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeregisterClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeregisterClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeregisterClusterCommand(output, context);
-    }
-}
+    };
+    return DeregisterClusterCommand;
+}($Command));
+export { DeregisterClusterCommand };

package/dist-es/commands/DescribeAddonCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeAddonRequestFilterSensitiveLog, DescribeAddonResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeAddonCommand, serializeAws_restJson1DescribeAddonCommand, } from "../protocols/Aws_restJson1";
-export class DescribeAddonCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeAddonCommand = (function (_super) {
+    __extends(DescribeAddonCommand, _super);
+    function DescribeAddonCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeAddonCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeAddonCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeAddonCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeAddonRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeAddonResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeAddonCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeAddonCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeAddonCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeAddonCommand(output, context);
-    }
-}
+    };
+    return DescribeAddonCommand;
+}($Command));
+export { DescribeAddonCommand };

package/dist-es/commands/DescribeAddonVersionsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeAddonVersionsRequestFilterSensitiveLog, DescribeAddonVersionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeAddonVersionsCommand, serializeAws_restJson1DescribeAddonVersionsCommand, } from "../protocols/Aws_restJson1";
-export class DescribeAddonVersionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeAddonVersionsCommand = (function (_super) {
+    __extends(DescribeAddonVersionsCommand, _super);
+    function DescribeAddonVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeAddonVersionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeAddonVersionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeAddonVersionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeAddonVersionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeAddonVersionsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeAddonVersionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeAddonVersionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeAddonVersionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeAddonVersionsCommand(output, context);
-    }
-}
+    };
+    return DescribeAddonVersionsCommand;
+}($Command));
+export { DescribeAddonVersionsCommand };

package/dist-es/commands/DescribeClusterCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeClusterRequestFilterSensitiveLog, DescribeClusterResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeClusterCommand, serializeAws_restJson1DescribeClusterCommand, } from "../protocols/Aws_restJson1";
-export class DescribeClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeClusterCommand = (function (_super) {
+    __extends(DescribeClusterCommand, _super);
+    function DescribeClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeClusterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeClusterRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeClusterResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeClusterCommand(output, context);
-    }
-}
+    };
+    return DescribeClusterCommand;
+}($Command));
+export { DescribeClusterCommand };

package/dist-es/commands/DescribeFargateProfileCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeFargateProfileRequestFilterSensitiveLog, DescribeFargateProfileResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeFargateProfileCommand, serializeAws_restJson1DescribeFargateProfileCommand, } from "../protocols/Aws_restJson1";
-export class DescribeFargateProfileCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeFargateProfileCommand = (function (_super) {
+    __extends(DescribeFargateProfileCommand, _super);
+    function DescribeFargateProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeFargateProfileCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeFargateProfileCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeFargateProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeFargateProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeFargateProfileResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeFargateProfileCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeFargateProfileCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeFargateProfileCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeFargateProfileCommand(output, context);
-    }
-}
+    };
+    return DescribeFargateProfileCommand;
+}($Command));
+export { DescribeFargateProfileCommand };

package/dist-es/commands/DescribeIdentityProviderConfigCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeIdentityProviderConfigRequestFilterSensitiveLog, DescribeIdentityProviderConfigResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeIdentityProviderConfigCommand, serializeAws_restJson1DescribeIdentityProviderConfigCommand, } from "../protocols/Aws_restJson1";
-export class DescribeIdentityProviderConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeIdentityProviderConfigCommand = (function (_super) {
+    __extends(DescribeIdentityProviderConfigCommand, _super);
+    function DescribeIdentityProviderConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeIdentityProviderConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeIdentityProviderConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeIdentityProviderConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeIdentityProviderConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeIdentityProviderConfigResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeIdentityProviderConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeIdentityProviderConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeIdentityProviderConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeIdentityProviderConfigCommand(output, context);
-    }
-}
+    };
+    return DescribeIdentityProviderConfigCommand;
+}($Command));
+export { DescribeIdentityProviderConfigCommand };

package/dist-es/commands/DescribeNodegroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeNodegroupRequestFilterSensitiveLog, DescribeNodegroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeNodegroupCommand, serializeAws_restJson1DescribeNodegroupCommand, } from "../protocols/Aws_restJson1";
-export class DescribeNodegroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeNodegroupCommand = (function (_super) {
+    __extends(DescribeNodegroupCommand, _super);
+    function DescribeNodegroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeNodegroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeNodegroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeNodegroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeNodegroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeNodegroupResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeNodegroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeNodegroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeNodegroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeNodegroupCommand(output, context);
-    }
-}
+    };
+    return DescribeNodegroupCommand;
+}($Command));
+export { DescribeNodegroupCommand };

package/dist-es/commands/DescribeUpdateCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeUpdateRequestFilterSensitiveLog, DescribeUpdateResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DescribeUpdateCommand, serializeAws_restJson1DescribeUpdateCommand, } from "../protocols/Aws_restJson1";
-export class DescribeUpdateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeUpdateCommand = (function (_super) {
+    __extends(DescribeUpdateCommand, _super);
+    function DescribeUpdateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeUpdateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DescribeUpdateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DescribeUpdateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeUpdateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeUpdateResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeUpdateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DescribeUpdateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeUpdateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DescribeUpdateCommand(output, context);
-    }
-}
+    };
+    return DescribeUpdateCommand;
+}($Command));
+export { DescribeUpdateCommand };

package/dist-es/commands/DisassociateIdentityProviderConfigCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DisassociateIdentityProviderConfigRequestFilterSensitiveLog, DisassociateIdentityProviderConfigResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DisassociateIdentityProviderConfigCommand, serializeAws_restJson1DisassociateIdentityProviderConfigCommand, } from "../protocols/Aws_restJson1";
-export class DisassociateIdentityProviderConfigCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DisassociateIdentityProviderConfigCommand = (function (_super) {
+    __extends(DisassociateIdentityProviderConfigCommand, _super);
+    function DisassociateIdentityProviderConfigCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DisassociateIdentityProviderConfigCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EKSClient";
-        const commandName = "DisassociateIdentityProviderConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EKSClient";
+        var commandName = "DisassociateIdentityProviderConfigCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DisassociateIdentityProviderConfigRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DisassociateIdentityProviderConfigResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateIdentityProviderConfigCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DisassociateIdentityProviderConfigCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DisassociateIdentityProviderConfigCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DisassociateIdentityProviderConfigCommand(output, context);
-    }
-}
+    };
+    return DisassociateIdentityProviderConfigCommand;
+}($Command));
+export { DisassociateIdentityProviderConfigCommand };