@aws-sdk/client-outposts 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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