OutpostsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/outposts/OutpostsPaginationBase.h>
#include <aws/outposts/OutpostsServiceClientModel.h>
#include <aws/outposts/OutpostsWaiter.h>
#include <aws/outposts/Outposts_EXPORTS.h>
 
namespace Aws {
namespace Outposts {
class AWS_OUTPOSTS_API OutpostsClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<OutpostsClient>,
                                        public OutpostsPaginationBase<OutpostsClient>,
                                        public OutpostsWaiter<OutpostsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef OutpostsClientConfiguration ClientConfigurationType;
  typedef OutpostsEndpointProvider EndpointProviderType;
 
  OutpostsClient(const Aws::Outposts::OutpostsClientConfiguration& clientConfiguration = Aws::Outposts::OutpostsClientConfiguration(),
                 std::shared_ptr<OutpostsEndpointProviderBase> endpointProvider = nullptr);
 
  OutpostsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<OutpostsEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Outposts::OutpostsClientConfiguration& clientConfiguration = Aws::Outposts::OutpostsClientConfiguration());
 
  OutpostsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<OutpostsEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::Outposts::OutpostsClientConfiguration& clientConfiguration = Aws::Outposts::OutpostsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  OutpostsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OutpostsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OutpostsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~OutpostsClient();
 
  virtual Model::CancelCapacityTaskOutcome CancelCapacityTask(const Model::CancelCapacityTaskRequest& request) const;
 
  template <typename CancelCapacityTaskRequestT = Model::CancelCapacityTaskRequest>
  Model::CancelCapacityTaskOutcomeCallable CancelCapacityTaskCallable(const CancelCapacityTaskRequestT& request) const {
    return SubmitCallable(&OutpostsClient::CancelCapacityTask, request);
  }
 
  template <typename CancelCapacityTaskRequestT = Model::CancelCapacityTaskRequest>
  void CancelCapacityTaskAsync(const CancelCapacityTaskRequestT& request, const CancelCapacityTaskResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::CancelCapacityTask, request, handler, context);
  }
 
  virtual Model::CancelOrderOutcome CancelOrder(const Model::CancelOrderRequest& request) const;
 
  template <typename CancelOrderRequestT = Model::CancelOrderRequest>
  Model::CancelOrderOutcomeCallable CancelOrderCallable(const CancelOrderRequestT& request) const {
    return SubmitCallable(&OutpostsClient::CancelOrder, request);
  }
 
  template <typename CancelOrderRequestT = Model::CancelOrderRequest>
  void CancelOrderAsync(const CancelOrderRequestT& request, const CancelOrderResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::CancelOrder, request, handler, context);
  }
 
  virtual Model::CreateOrderOutcome CreateOrder(const Model::CreateOrderRequest& request) const;
 
  template <typename CreateOrderRequestT = Model::CreateOrderRequest>
  Model::CreateOrderOutcomeCallable CreateOrderCallable(const CreateOrderRequestT& request) const {
    return SubmitCallable(&OutpostsClient::CreateOrder, request);
  }
 
  template <typename CreateOrderRequestT = Model::CreateOrderRequest>
  void CreateOrderAsync(const CreateOrderRequestT& request, const CreateOrderResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::CreateOrder, request, handler, context);
  }
 
  virtual Model::CreateOutpostOutcome CreateOutpost(const Model::CreateOutpostRequest& request) const;
 
  template <typename CreateOutpostRequestT = Model::CreateOutpostRequest>
  Model::CreateOutpostOutcomeCallable CreateOutpostCallable(const CreateOutpostRequestT& request) const {
    return SubmitCallable(&OutpostsClient::CreateOutpost, request);
  }
 
  template <typename CreateOutpostRequestT = Model::CreateOutpostRequest>
  void CreateOutpostAsync(const CreateOutpostRequestT& request, const CreateOutpostResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::CreateOutpost, request, handler, context);
  }
 
  virtual Model::CreateSiteOutcome CreateSite(const Model::CreateSiteRequest& request) const;
 
  template <typename CreateSiteRequestT = Model::CreateSiteRequest>
  Model::CreateSiteOutcomeCallable CreateSiteCallable(const CreateSiteRequestT& request) const {
    return SubmitCallable(&OutpostsClient::CreateSite, request);
  }
 
  template <typename CreateSiteRequestT = Model::CreateSiteRequest>
  void CreateSiteAsync(const CreateSiteRequestT& request, const CreateSiteResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::CreateSite, request, handler, context);
  }
 
  virtual Model::DeleteOutpostOutcome DeleteOutpost(const Model::DeleteOutpostRequest& request) const;
 
  template <typename DeleteOutpostRequestT = Model::DeleteOutpostRequest>
  Model::DeleteOutpostOutcomeCallable DeleteOutpostCallable(const DeleteOutpostRequestT& request) const {
    return SubmitCallable(&OutpostsClient::DeleteOutpost, request);
  }
 
  template <typename DeleteOutpostRequestT = Model::DeleteOutpostRequest>
  void DeleteOutpostAsync(const DeleteOutpostRequestT& request, const DeleteOutpostResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::DeleteOutpost, request, handler, context);
  }
 
  virtual Model::DeleteSiteOutcome DeleteSite(const Model::DeleteSiteRequest& request) const;
 
  template <typename DeleteSiteRequestT = Model::DeleteSiteRequest>
  Model::DeleteSiteOutcomeCallable DeleteSiteCallable(const DeleteSiteRequestT& request) const {
    return SubmitCallable(&OutpostsClient::DeleteSite, request);
  }
 
  template <typename DeleteSiteRequestT = Model::DeleteSiteRequest>
  void DeleteSiteAsync(const DeleteSiteRequestT& request, const DeleteSiteResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::DeleteSite, request, handler, context);
  }
 
  virtual Model::GetCapacityTaskOutcome GetCapacityTask(const Model::GetCapacityTaskRequest& request) const;
 
  template <typename GetCapacityTaskRequestT = Model::GetCapacityTaskRequest>
  Model::GetCapacityTaskOutcomeCallable GetCapacityTaskCallable(const GetCapacityTaskRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetCapacityTask, request);
  }
 
  template <typename GetCapacityTaskRequestT = Model::GetCapacityTaskRequest>
  void GetCapacityTaskAsync(const GetCapacityTaskRequestT& request, const GetCapacityTaskResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetCapacityTask, request, handler, context);
  }
 
  virtual Model::GetCatalogItemOutcome GetCatalogItem(const Model::GetCatalogItemRequest& request) const;
 
  template <typename GetCatalogItemRequestT = Model::GetCatalogItemRequest>
  Model::GetCatalogItemOutcomeCallable GetCatalogItemCallable(const GetCatalogItemRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetCatalogItem, request);
  }
 
  template <typename GetCatalogItemRequestT = Model::GetCatalogItemRequest>
  void GetCatalogItemAsync(const GetCatalogItemRequestT& request, const GetCatalogItemResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetCatalogItem, request, handler, context);
  }
 
  virtual Model::GetConnectionOutcome GetConnection(const Model::GetConnectionRequest& request) const;
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  Model::GetConnectionOutcomeCallable GetConnectionCallable(const GetConnectionRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetConnection, request);
  }
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  void GetConnectionAsync(const GetConnectionRequestT& request, const GetConnectionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetConnection, request, handler, context);
  }
 
  virtual Model::GetOrderOutcome GetOrder(const Model::GetOrderRequest& request) const;
 
  template <typename GetOrderRequestT = Model::GetOrderRequest>
  Model::GetOrderOutcomeCallable GetOrderCallable(const GetOrderRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetOrder, request);
  }
 
  template <typename GetOrderRequestT = Model::GetOrderRequest>
  void GetOrderAsync(const GetOrderRequestT& request, const GetOrderResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetOrder, request, handler, context);
  }
 
  virtual Model::GetOutpostOutcome GetOutpost(const Model::GetOutpostRequest& request) const;
 
  template <typename GetOutpostRequestT = Model::GetOutpostRequest>
  Model::GetOutpostOutcomeCallable GetOutpostCallable(const GetOutpostRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetOutpost, request);
  }
 
  template <typename GetOutpostRequestT = Model::GetOutpostRequest>
  void GetOutpostAsync(const GetOutpostRequestT& request, const GetOutpostResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetOutpost, request, handler, context);
  }
 
  virtual Model::GetOutpostBillingInformationOutcome GetOutpostBillingInformation(
      const Model::GetOutpostBillingInformationRequest& request) const;
 
  template <typename GetOutpostBillingInformationRequestT = Model::GetOutpostBillingInformationRequest>
  Model::GetOutpostBillingInformationOutcomeCallable GetOutpostBillingInformationCallable(
      const GetOutpostBillingInformationRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetOutpostBillingInformation, request);
  }
 
  template <typename GetOutpostBillingInformationRequestT = Model::GetOutpostBillingInformationRequest>
  void GetOutpostBillingInformationAsync(const GetOutpostBillingInformationRequestT& request,
                                         const GetOutpostBillingInformationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetOutpostBillingInformation, request, handler, context);
  }
 
  virtual Model::GetOutpostInstanceTypesOutcome GetOutpostInstanceTypes(const Model::GetOutpostInstanceTypesRequest& request) const;
 
  template <typename GetOutpostInstanceTypesRequestT = Model::GetOutpostInstanceTypesRequest>
  Model::GetOutpostInstanceTypesOutcomeCallable GetOutpostInstanceTypesCallable(const GetOutpostInstanceTypesRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetOutpostInstanceTypes, request);
  }
 
  template <typename GetOutpostInstanceTypesRequestT = Model::GetOutpostInstanceTypesRequest>
  void GetOutpostInstanceTypesAsync(const GetOutpostInstanceTypesRequestT& request,
                                    const GetOutpostInstanceTypesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetOutpostInstanceTypes, request, handler, context);
  }
 
  virtual Model::GetOutpostSupportedInstanceTypesOutcome GetOutpostSupportedInstanceTypes(
      const Model::GetOutpostSupportedInstanceTypesRequest& request) const;
 
  template <typename GetOutpostSupportedInstanceTypesRequestT = Model::GetOutpostSupportedInstanceTypesRequest>
  Model::GetOutpostSupportedInstanceTypesOutcomeCallable GetOutpostSupportedInstanceTypesCallable(
      const GetOutpostSupportedInstanceTypesRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetOutpostSupportedInstanceTypes, request);
  }
 
  template <typename GetOutpostSupportedInstanceTypesRequestT = Model::GetOutpostSupportedInstanceTypesRequest>
  void GetOutpostSupportedInstanceTypesAsync(const GetOutpostSupportedInstanceTypesRequestT& request,
                                             const GetOutpostSupportedInstanceTypesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetOutpostSupportedInstanceTypes, request, handler, context);
  }
 
  virtual Model::GetSiteOutcome GetSite(const Model::GetSiteRequest& request) const;
 
  template <typename GetSiteRequestT = Model::GetSiteRequest>
  Model::GetSiteOutcomeCallable GetSiteCallable(const GetSiteRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetSite, request);
  }
 
  template <typename GetSiteRequestT = Model::GetSiteRequest>
  void GetSiteAsync(const GetSiteRequestT& request, const GetSiteResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetSite, request, handler, context);
  }
 
  virtual Model::GetSiteAddressOutcome GetSiteAddress(const Model::GetSiteAddressRequest& request) const;
 
  template <typename GetSiteAddressRequestT = Model::GetSiteAddressRequest>
  Model::GetSiteAddressOutcomeCallable GetSiteAddressCallable(const GetSiteAddressRequestT& request) const {
    return SubmitCallable(&OutpostsClient::GetSiteAddress, request);
  }
 
  template <typename GetSiteAddressRequestT = Model::GetSiteAddressRequest>
  void GetSiteAddressAsync(const GetSiteAddressRequestT& request, const GetSiteAddressResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::GetSiteAddress, request, handler, context);
  }
 
  virtual Model::ListAssetInstancesOutcome ListAssetInstances(const Model::ListAssetInstancesRequest& request) const;
 
  template <typename ListAssetInstancesRequestT = Model::ListAssetInstancesRequest>
  Model::ListAssetInstancesOutcomeCallable ListAssetInstancesCallable(const ListAssetInstancesRequestT& request) const {
    return SubmitCallable(&OutpostsClient::ListAssetInstances, request);
  }
 
  template <typename ListAssetInstancesRequestT = Model::ListAssetInstancesRequest>
  void ListAssetInstancesAsync(const ListAssetInstancesRequestT& request, const ListAssetInstancesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::ListAssetInstances, request, handler, context);
  }
 
  virtual Model::ListAssetsOutcome ListAssets(const Model::ListAssetsRequest& request) const;
 
  template <typename ListAssetsRequestT = Model::ListAssetsRequest>
  Model::ListAssetsOutcomeCallable ListAssetsCallable(const ListAssetsRequestT& request) const {
    return SubmitCallable(&OutpostsClient::ListAssets, request);
  }
 
  template <typename ListAssetsRequestT = Model::ListAssetsRequest>
  void ListAssetsAsync(const ListAssetsRequestT& request, const ListAssetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::ListAssets, request, handler, context);
  }
 
  virtual Model::ListBlockingInstancesForCapacityTaskOutcome ListBlockingInstancesForCapacityTask(
      const Model::ListBlockingInstancesForCapacityTaskRequest& request) const;
 
  template <typename ListBlockingInstancesForCapacityTaskRequestT = Model::ListBlockingInstancesForCapacityTaskRequest>
  Model::ListBlockingInstancesForCapacityTaskOutcomeCallable ListBlockingInstancesForCapacityTaskCallable(
      const ListBlockingInstancesForCapacityTaskRequestT& request) const {
    return SubmitCallable(&OutpostsClient::ListBlockingInstancesForCapacityTask, request);
  }
 
  template <typename ListBlockingInstancesForCapacityTaskRequestT = Model::ListBlockingInstancesForCapacityTaskRequest>
  void ListBlockingInstancesForCapacityTaskAsync(const ListBlockingInstancesForCapacityTaskRequestT& request,
                                                 const ListBlockingInstancesForCapacityTaskResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::ListBlockingInstancesForCapacityTask, request, handler, context);
  }
 
  virtual Model::ListCapacityTasksOutcome ListCapacityTasks(const Model::ListCapacityTasksRequest& request = {}) const;
 
  template <typename ListCapacityTasksRequestT = Model::ListCapacityTasksRequest>
  Model::ListCapacityTasksOutcomeCallable ListCapacityTasksCallable(const ListCapacityTasksRequestT& request = {}) const {
    return SubmitCallable(&OutpostsClient::ListCapacityTasks, request);
  }
 
  template <typename ListCapacityTasksRequestT = Model::ListCapacityTasksRequest>
  void ListCapacityTasksAsync(const ListCapacityTasksResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListCapacityTasksRequestT& request = {}) const {
    return SubmitAsync(&OutpostsClient::ListCapacityTasks, request, handler, context);
  }
 
  virtual Model::ListCatalogItemsOutcome ListCatalogItems(const Model::ListCatalogItemsRequest& request = {}) const;
 
  template <typename ListCatalogItemsRequestT = Model::ListCatalogItemsRequest>
  Model::ListCatalogItemsOutcomeCallable ListCatalogItemsCallable(const ListCatalogItemsRequestT& request = {}) const {
    return SubmitCallable(&OutpostsClient::ListCatalogItems, request);
  }
 
  template <typename ListCatalogItemsRequestT = Model::ListCatalogItemsRequest>
  void ListCatalogItemsAsync(const ListCatalogItemsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListCatalogItemsRequestT& request = {}) const {
    return SubmitAsync(&OutpostsClient::ListCatalogItems, request, handler, context);
  }
 
  virtual Model::ListOrdersOutcome ListOrders(const Model::ListOrdersRequest& request = {}) const;
 
  template <typename ListOrdersRequestT = Model::ListOrdersRequest>
  Model::ListOrdersOutcomeCallable ListOrdersCallable(const ListOrdersRequestT& request = {}) const {
    return SubmitCallable(&OutpostsClient::ListOrders, request);
  }
 
  template <typename ListOrdersRequestT = Model::ListOrdersRequest>
  void ListOrdersAsync(const ListOrdersResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListOrdersRequestT& request = {}) const {
    return SubmitAsync(&OutpostsClient::ListOrders, request, handler, context);
  }
 
  virtual Model::ListOutpostsOutcome ListOutposts(const Model::ListOutpostsRequest& request = {}) const;
 
  template <typename ListOutpostsRequestT = Model::ListOutpostsRequest>
  Model::ListOutpostsOutcomeCallable ListOutpostsCallable(const ListOutpostsRequestT& request = {}) const {
    return SubmitCallable(&OutpostsClient::ListOutposts, request);
  }
 
  template <typename ListOutpostsRequestT = Model::ListOutpostsRequest>
  void ListOutpostsAsync(const ListOutpostsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListOutpostsRequestT& request = {}) const {
    return SubmitAsync(&OutpostsClient::ListOutposts, request, handler, context);
  }
 
  virtual Model::ListSitesOutcome ListSites(const Model::ListSitesRequest& request = {}) const;
 
  template <typename ListSitesRequestT = Model::ListSitesRequest>
  Model::ListSitesOutcomeCallable ListSitesCallable(const ListSitesRequestT& request = {}) const {
    return SubmitCallable(&OutpostsClient::ListSites, request);
  }
 
  template <typename ListSitesRequestT = Model::ListSitesRequest>
  void ListSitesAsync(const ListSitesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListSitesRequestT& request = {}) const {
    return SubmitAsync(&OutpostsClient::ListSites, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&OutpostsClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartCapacityTaskOutcome StartCapacityTask(const Model::StartCapacityTaskRequest& request) const;
 
  template <typename StartCapacityTaskRequestT = Model::StartCapacityTaskRequest>
  Model::StartCapacityTaskOutcomeCallable StartCapacityTaskCallable(const StartCapacityTaskRequestT& request) const {
    return SubmitCallable(&OutpostsClient::StartCapacityTask, request);
  }
 
  template <typename StartCapacityTaskRequestT = Model::StartCapacityTaskRequest>
  void StartCapacityTaskAsync(const StartCapacityTaskRequestT& request, const StartCapacityTaskResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::StartCapacityTask, request, handler, context);
  }
 
  virtual Model::StartConnectionOutcome StartConnection(const Model::StartConnectionRequest& request) const;
 
  template <typename StartConnectionRequestT = Model::StartConnectionRequest>
  Model::StartConnectionOutcomeCallable StartConnectionCallable(const StartConnectionRequestT& request) const {
    return SubmitCallable(&OutpostsClient::StartConnection, request);
  }
 
  template <typename StartConnectionRequestT = Model::StartConnectionRequest>
  void StartConnectionAsync(const StartConnectionRequestT& request, const StartConnectionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::StartConnection, request, handler, context);
  }
 
  virtual Model::StartOutpostDecommissionOutcome StartOutpostDecommission(const Model::StartOutpostDecommissionRequest& request) const;
 
  template <typename StartOutpostDecommissionRequestT = Model::StartOutpostDecommissionRequest>
  Model::StartOutpostDecommissionOutcomeCallable StartOutpostDecommissionCallable(const StartOutpostDecommissionRequestT& request) const {
    return SubmitCallable(&OutpostsClient::StartOutpostDecommission, request);
  }
 
  template <typename StartOutpostDecommissionRequestT = Model::StartOutpostDecommissionRequest>
  void StartOutpostDecommissionAsync(const StartOutpostDecommissionRequestT& request,
                                     const StartOutpostDecommissionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::StartOutpostDecommission, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&OutpostsClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&OutpostsClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateOutpostOutcome UpdateOutpost(const Model::UpdateOutpostRequest& request) const;
 
  template <typename UpdateOutpostRequestT = Model::UpdateOutpostRequest>
  Model::UpdateOutpostOutcomeCallable UpdateOutpostCallable(const UpdateOutpostRequestT& request) const {
    return SubmitCallable(&OutpostsClient::UpdateOutpost, request);
  }
 
  template <typename UpdateOutpostRequestT = Model::UpdateOutpostRequest>
  void UpdateOutpostAsync(const UpdateOutpostRequestT& request, const UpdateOutpostResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::UpdateOutpost, request, handler, context);
  }
 
  virtual Model::UpdateSiteOutcome UpdateSite(const Model::UpdateSiteRequest& request) const;
 
  template <typename UpdateSiteRequestT = Model::UpdateSiteRequest>
  Model::UpdateSiteOutcomeCallable UpdateSiteCallable(const UpdateSiteRequestT& request) const {
    return SubmitCallable(&OutpostsClient::UpdateSite, request);
  }
 
  template <typename UpdateSiteRequestT = Model::UpdateSiteRequest>
  void UpdateSiteAsync(const UpdateSiteRequestT& request, const UpdateSiteResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::UpdateSite, request, handler, context);
  }
 
  virtual Model::UpdateSiteAddressOutcome UpdateSiteAddress(const Model::UpdateSiteAddressRequest& request) const;
 
  template <typename UpdateSiteAddressRequestT = Model::UpdateSiteAddressRequest>
  Model::UpdateSiteAddressOutcomeCallable UpdateSiteAddressCallable(const UpdateSiteAddressRequestT& request) const {
    return SubmitCallable(&OutpostsClient::UpdateSiteAddress, request);
  }
 
  template <typename UpdateSiteAddressRequestT = Model::UpdateSiteAddressRequest>
  void UpdateSiteAddressAsync(const UpdateSiteAddressRequestT& request, const UpdateSiteAddressResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::UpdateSiteAddress, request, handler, context);
  }
 
  virtual Model::UpdateSiteRackPhysicalPropertiesOutcome UpdateSiteRackPhysicalProperties(
      const Model::UpdateSiteRackPhysicalPropertiesRequest& request) const;
 
  template <typename UpdateSiteRackPhysicalPropertiesRequestT = Model::UpdateSiteRackPhysicalPropertiesRequest>
  Model::UpdateSiteRackPhysicalPropertiesOutcomeCallable UpdateSiteRackPhysicalPropertiesCallable(
      const UpdateSiteRackPhysicalPropertiesRequestT& request) const {
    return SubmitCallable(&OutpostsClient::UpdateSiteRackPhysicalProperties, request);
  }
 
  template <typename UpdateSiteRackPhysicalPropertiesRequestT = Model::UpdateSiteRackPhysicalPropertiesRequest>
  void UpdateSiteRackPhysicalPropertiesAsync(const UpdateSiteRackPhysicalPropertiesRequestT& request,
                                             const UpdateSiteRackPhysicalPropertiesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OutpostsClient::UpdateSiteRackPhysicalProperties, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<OutpostsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<OutpostsClient>;
  void init(const OutpostsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, OutpostsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  OutpostsClientConfiguration m_clientConfiguration;
  std::shared_ptr<OutpostsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Outposts
}  // namespace Aws