@aws-sdk/client-managedblockchain 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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