@aws-sdk/client-iam 3.183.0 → 3.185.0

package/dist-es/commands/CreateGroupCommand.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 { CreateGroupRequestFilterSensitiveLog, CreateGroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateGroupCommand, serializeAws_queryCreateGroupCommand } from "../protocols/Aws_query";
-export class CreateGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateGroupCommand = (function (_super) {
+    __extends(CreateGroupCommand, _super);
+    function CreateGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateGroupCommand.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 = "IAMClient";
-        const commandName = "CreateGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateGroupResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateGroupCommand(output, context);
-    }
-}
+    };
+    return CreateGroupCommand;
+}($Command));
+export { CreateGroupCommand };

package/dist-es/commands/CreateInstanceProfileCommand.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 { CreateInstanceProfileRequestFilterSensitiveLog, CreateInstanceProfileResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateInstanceProfileCommand, serializeAws_queryCreateInstanceProfileCommand, } from "../protocols/Aws_query";
-export class CreateInstanceProfileCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateInstanceProfileCommand = (function (_super) {
+    __extends(CreateInstanceProfileCommand, _super);
+    function CreateInstanceProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateInstanceProfileCommand.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 = "IAMClient";
-        const commandName = "CreateInstanceProfileCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateInstanceProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateInstanceProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateInstanceProfileResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateInstanceProfileCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateInstanceProfileCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateInstanceProfileCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateInstanceProfileCommand(output, context);
-    }
-}
+    };
+    return CreateInstanceProfileCommand;
+}($Command));
+export { CreateInstanceProfileCommand };

package/dist-es/commands/CreateLoginProfileCommand.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 { CreateLoginProfileRequestFilterSensitiveLog, CreateLoginProfileResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateLoginProfileCommand, serializeAws_queryCreateLoginProfileCommand, } from "../protocols/Aws_query";
-export class CreateLoginProfileCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateLoginProfileCommand = (function (_super) {
+    __extends(CreateLoginProfileCommand, _super);
+    function CreateLoginProfileCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateLoginProfileCommand.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 = "IAMClient";
-        const commandName = "CreateLoginProfileCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateLoginProfileCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateLoginProfileRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateLoginProfileResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateLoginProfileCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateLoginProfileCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateLoginProfileCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateLoginProfileCommand(output, context);
-    }
-}
+    };
+    return CreateLoginProfileCommand;
+}($Command));
+export { CreateLoginProfileCommand };

package/dist-es/commands/CreateOpenIDConnectProviderCommand.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 { CreateOpenIDConnectProviderRequestFilterSensitiveLog, CreateOpenIDConnectProviderResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateOpenIDConnectProviderCommand, serializeAws_queryCreateOpenIDConnectProviderCommand, } from "../protocols/Aws_query";
-export class CreateOpenIDConnectProviderCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateOpenIDConnectProviderCommand = (function (_super) {
+    __extends(CreateOpenIDConnectProviderCommand, _super);
+    function CreateOpenIDConnectProviderCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateOpenIDConnectProviderCommand.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 = "IAMClient";
-        const commandName = "CreateOpenIDConnectProviderCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateOpenIDConnectProviderCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateOpenIDConnectProviderRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateOpenIDConnectProviderResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateOpenIDConnectProviderCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateOpenIDConnectProviderCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateOpenIDConnectProviderCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateOpenIDConnectProviderCommand(output, context);
-    }
-}
+    };
+    return CreateOpenIDConnectProviderCommand;
+}($Command));
+export { CreateOpenIDConnectProviderCommand };

package/dist-es/commands/CreatePolicyCommand.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 { CreatePolicyRequestFilterSensitiveLog, CreatePolicyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreatePolicyCommand, serializeAws_queryCreatePolicyCommand } from "../protocols/Aws_query";
-export class CreatePolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreatePolicyCommand = (function (_super) {
+    __extends(CreatePolicyCommand, _super);
+    function CreatePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreatePolicyCommand.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 = "IAMClient";
-        const commandName = "CreatePolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreatePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreatePolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreatePolicyResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreatePolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreatePolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreatePolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreatePolicyCommand(output, context);
-    }
-}
+    };
+    return CreatePolicyCommand;
+}($Command));
+export { CreatePolicyCommand };

package/dist-es/commands/CreatePolicyVersionCommand.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 { CreatePolicyVersionRequestFilterSensitiveLog, CreatePolicyVersionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreatePolicyVersionCommand, serializeAws_queryCreatePolicyVersionCommand, } from "../protocols/Aws_query";
-export class CreatePolicyVersionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreatePolicyVersionCommand = (function (_super) {
+    __extends(CreatePolicyVersionCommand, _super);
+    function CreatePolicyVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreatePolicyVersionCommand.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 = "IAMClient";
-        const commandName = "CreatePolicyVersionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreatePolicyVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreatePolicyVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreatePolicyVersionResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreatePolicyVersionCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreatePolicyVersionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreatePolicyVersionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreatePolicyVersionCommand(output, context);
-    }
-}
+    };
+    return CreatePolicyVersionCommand;
+}($Command));
+export { CreatePolicyVersionCommand };

package/dist-es/commands/CreateRoleCommand.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 { CreateRoleRequestFilterSensitiveLog, CreateRoleResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateRoleCommand, serializeAws_queryCreateRoleCommand } from "../protocols/Aws_query";
-export class CreateRoleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateRoleCommand = (function (_super) {
+    __extends(CreateRoleCommand, _super);
+    function CreateRoleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateRoleCommand.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 = "IAMClient";
-        const commandName = "CreateRoleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateRoleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateRoleRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateRoleResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateRoleCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateRoleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateRoleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateRoleCommand(output, context);
-    }
-}
+    };
+    return CreateRoleCommand;
+}($Command));
+export { CreateRoleCommand };

package/dist-es/commands/CreateSAMLProviderCommand.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 { CreateSAMLProviderRequestFilterSensitiveLog, CreateSAMLProviderResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateSAMLProviderCommand, serializeAws_queryCreateSAMLProviderCommand, } from "../protocols/Aws_query";
-export class CreateSAMLProviderCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateSAMLProviderCommand = (function (_super) {
+    __extends(CreateSAMLProviderCommand, _super);
+    function CreateSAMLProviderCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateSAMLProviderCommand.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 = "IAMClient";
-        const commandName = "CreateSAMLProviderCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateSAMLProviderCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateSAMLProviderRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateSAMLProviderResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateSAMLProviderCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateSAMLProviderCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateSAMLProviderCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateSAMLProviderCommand(output, context);
-    }
-}
+    };
+    return CreateSAMLProviderCommand;
+}($Command));
+export { CreateSAMLProviderCommand };

package/dist-es/commands/CreateServiceLinkedRoleCommand.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 { CreateServiceLinkedRoleRequestFilterSensitiveLog, CreateServiceLinkedRoleResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateServiceLinkedRoleCommand, serializeAws_queryCreateServiceLinkedRoleCommand, } from "../protocols/Aws_query";
-export class CreateServiceLinkedRoleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateServiceLinkedRoleCommand = (function (_super) {
+    __extends(CreateServiceLinkedRoleCommand, _super);
+    function CreateServiceLinkedRoleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateServiceLinkedRoleCommand.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 = "IAMClient";
-        const commandName = "CreateServiceLinkedRoleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateServiceLinkedRoleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateServiceLinkedRoleRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateServiceLinkedRoleResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateServiceLinkedRoleCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateServiceLinkedRoleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateServiceLinkedRoleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateServiceLinkedRoleCommand(output, context);
-    }
-}
+    };
+    return CreateServiceLinkedRoleCommand;
+}($Command));
+export { CreateServiceLinkedRoleCommand };

package/dist-es/commands/CreateServiceSpecificCredentialCommand.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 { CreateServiceSpecificCredentialRequestFilterSensitiveLog, CreateServiceSpecificCredentialResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateServiceSpecificCredentialCommand, serializeAws_queryCreateServiceSpecificCredentialCommand, } from "../protocols/Aws_query";
-export class CreateServiceSpecificCredentialCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateServiceSpecificCredentialCommand = (function (_super) {
+    __extends(CreateServiceSpecificCredentialCommand, _super);
+    function CreateServiceSpecificCredentialCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateServiceSpecificCredentialCommand.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 = "IAMClient";
-        const commandName = "CreateServiceSpecificCredentialCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IAMClient";
+        var commandName = "CreateServiceSpecificCredentialCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateServiceSpecificCredentialRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateServiceSpecificCredentialResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateServiceSpecificCredentialCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryCreateServiceSpecificCredentialCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateServiceSpecificCredentialCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryCreateServiceSpecificCredentialCommand(output, context);
-    }
-}
+    };
+    return CreateServiceSpecificCredentialCommand;
+}($Command));
+export { CreateServiceSpecificCredentialCommand };