GroundStationClient.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/groundstation/GroundStationPaginationBase.h>
#include <aws/groundstation/GroundStationServiceClientModel.h>
#include <aws/groundstation/GroundStation_EXPORTS.h>
 
namespace Aws {
namespace GroundStation {
class AWS_GROUNDSTATION_API GroundStationClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<GroundStationClient>,
                                                  public GroundStationPaginationBase<GroundStationClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GroundStationClientConfiguration ClientConfigurationType;
  typedef GroundStationEndpointProvider EndpointProviderType;
 
  GroundStationClient(const Aws::GroundStation::GroundStationClientConfiguration& clientConfiguration =
                          Aws::GroundStation::GroundStationClientConfiguration(),
                      std::shared_ptr<GroundStationEndpointProviderBase> endpointProvider = nullptr);
 
  GroundStationClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<GroundStationEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::GroundStation::GroundStationClientConfiguration& clientConfiguration =
                          Aws::GroundStation::GroundStationClientConfiguration());
 
  GroundStationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<GroundStationEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::GroundStation::GroundStationClientConfiguration& clientConfiguration =
                          Aws::GroundStation::GroundStationClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GroundStationClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GroundStationClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GroundStationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GroundStationClient();
 
  virtual Model::CancelContactOutcome CancelContact(const Model::CancelContactRequest& request) const;
 
  template <typename CancelContactRequestT = Model::CancelContactRequest>
  Model::CancelContactOutcomeCallable CancelContactCallable(const CancelContactRequestT& request) const {
    return SubmitCallable(&GroundStationClient::CancelContact, request);
  }
 
  template <typename CancelContactRequestT = Model::CancelContactRequest>
  void CancelContactAsync(const CancelContactRequestT& request, const CancelContactResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::CancelContact, request, handler, context);
  }
 
  virtual Model::CreateConfigOutcome CreateConfig(const Model::CreateConfigRequest& request) const;
 
  template <typename CreateConfigRequestT = Model::CreateConfigRequest>
  Model::CreateConfigOutcomeCallable CreateConfigCallable(const CreateConfigRequestT& request) const {
    return SubmitCallable(&GroundStationClient::CreateConfig, request);
  }
 
  template <typename CreateConfigRequestT = Model::CreateConfigRequest>
  void CreateConfigAsync(const CreateConfigRequestT& request, const CreateConfigResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::CreateConfig, request, handler, context);
  }
 
  virtual Model::CreateDataflowEndpointGroupOutcome CreateDataflowEndpointGroup(
      const Model::CreateDataflowEndpointGroupRequest& request) const;
 
  template <typename CreateDataflowEndpointGroupRequestT = Model::CreateDataflowEndpointGroupRequest>
  Model::CreateDataflowEndpointGroupOutcomeCallable CreateDataflowEndpointGroupCallable(
      const CreateDataflowEndpointGroupRequestT& request) const {
    return SubmitCallable(&GroundStationClient::CreateDataflowEndpointGroup, request);
  }
 
  template <typename CreateDataflowEndpointGroupRequestT = Model::CreateDataflowEndpointGroupRequest>
  void CreateDataflowEndpointGroupAsync(const CreateDataflowEndpointGroupRequestT& request,
                                        const CreateDataflowEndpointGroupResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::CreateDataflowEndpointGroup, request, handler, context);
  }
 
  virtual Model::CreateDataflowEndpointGroupV2Outcome CreateDataflowEndpointGroupV2(
      const Model::CreateDataflowEndpointGroupV2Request& request) const;
 
  template <typename CreateDataflowEndpointGroupV2RequestT = Model::CreateDataflowEndpointGroupV2Request>
  Model::CreateDataflowEndpointGroupV2OutcomeCallable CreateDataflowEndpointGroupV2Callable(
      const CreateDataflowEndpointGroupV2RequestT& request) const {
    return SubmitCallable(&GroundStationClient::CreateDataflowEndpointGroupV2, request);
  }
 
  template <typename CreateDataflowEndpointGroupV2RequestT = Model::CreateDataflowEndpointGroupV2Request>
  void CreateDataflowEndpointGroupV2Async(const CreateDataflowEndpointGroupV2RequestT& request,
                                          const CreateDataflowEndpointGroupV2ResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::CreateDataflowEndpointGroupV2, request, handler, context);
  }
 
  virtual Model::CreateEphemerisOutcome CreateEphemeris(const Model::CreateEphemerisRequest& request) const;
 
  template <typename CreateEphemerisRequestT = Model::CreateEphemerisRequest>
  Model::CreateEphemerisOutcomeCallable CreateEphemerisCallable(const CreateEphemerisRequestT& request) const {
    return SubmitCallable(&GroundStationClient::CreateEphemeris, request);
  }
 
  template <typename CreateEphemerisRequestT = Model::CreateEphemerisRequest>
  void CreateEphemerisAsync(const CreateEphemerisRequestT& request, const CreateEphemerisResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::CreateEphemeris, request, handler, context);
  }
 
  virtual Model::CreateMissionProfileOutcome CreateMissionProfile(const Model::CreateMissionProfileRequest& request) const;
 
  template <typename CreateMissionProfileRequestT = Model::CreateMissionProfileRequest>
  Model::CreateMissionProfileOutcomeCallable CreateMissionProfileCallable(const CreateMissionProfileRequestT& request) const {
    return SubmitCallable(&GroundStationClient::CreateMissionProfile, request);
  }
 
  template <typename CreateMissionProfileRequestT = Model::CreateMissionProfileRequest>
  void CreateMissionProfileAsync(const CreateMissionProfileRequestT& request, const CreateMissionProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::CreateMissionProfile, request, handler, context);
  }
 
  virtual Model::DeleteConfigOutcome DeleteConfig(const Model::DeleteConfigRequest& request) const;
 
  template <typename DeleteConfigRequestT = Model::DeleteConfigRequest>
  Model::DeleteConfigOutcomeCallable DeleteConfigCallable(const DeleteConfigRequestT& request) const {
    return SubmitCallable(&GroundStationClient::DeleteConfig, request);
  }
 
  template <typename DeleteConfigRequestT = Model::DeleteConfigRequest>
  void DeleteConfigAsync(const DeleteConfigRequestT& request, const DeleteConfigResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::DeleteConfig, request, handler, context);
  }
 
  virtual Model::DeleteDataflowEndpointGroupOutcome DeleteDataflowEndpointGroup(
      const Model::DeleteDataflowEndpointGroupRequest& request) const;
 
  template <typename DeleteDataflowEndpointGroupRequestT = Model::DeleteDataflowEndpointGroupRequest>
  Model::DeleteDataflowEndpointGroupOutcomeCallable DeleteDataflowEndpointGroupCallable(
      const DeleteDataflowEndpointGroupRequestT& request) const {
    return SubmitCallable(&GroundStationClient::DeleteDataflowEndpointGroup, request);
  }
 
  template <typename DeleteDataflowEndpointGroupRequestT = Model::DeleteDataflowEndpointGroupRequest>
  void DeleteDataflowEndpointGroupAsync(const DeleteDataflowEndpointGroupRequestT& request,
                                        const DeleteDataflowEndpointGroupResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::DeleteDataflowEndpointGroup, request, handler, context);
  }
 
  virtual Model::DeleteEphemerisOutcome DeleteEphemeris(const Model::DeleteEphemerisRequest& request) const;
 
  template <typename DeleteEphemerisRequestT = Model::DeleteEphemerisRequest>
  Model::DeleteEphemerisOutcomeCallable DeleteEphemerisCallable(const DeleteEphemerisRequestT& request) const {
    return SubmitCallable(&GroundStationClient::DeleteEphemeris, request);
  }
 
  template <typename DeleteEphemerisRequestT = Model::DeleteEphemerisRequest>
  void DeleteEphemerisAsync(const DeleteEphemerisRequestT& request, const DeleteEphemerisResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::DeleteEphemeris, request, handler, context);
  }
 
  virtual Model::DeleteMissionProfileOutcome DeleteMissionProfile(const Model::DeleteMissionProfileRequest& request) const;
 
  template <typename DeleteMissionProfileRequestT = Model::DeleteMissionProfileRequest>
  Model::DeleteMissionProfileOutcomeCallable DeleteMissionProfileCallable(const DeleteMissionProfileRequestT& request) const {
    return SubmitCallable(&GroundStationClient::DeleteMissionProfile, request);
  }
 
  template <typename DeleteMissionProfileRequestT = Model::DeleteMissionProfileRequest>
  void DeleteMissionProfileAsync(const DeleteMissionProfileRequestT& request, const DeleteMissionProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::DeleteMissionProfile, request, handler, context);
  }
 
  virtual Model::DescribeContactOutcome DescribeContact(const Model::DescribeContactRequest& request) const;
 
  template <typename DescribeContactRequestT = Model::DescribeContactRequest>
  Model::DescribeContactOutcomeCallable DescribeContactCallable(const DescribeContactRequestT& request) const {
    return SubmitCallable(&GroundStationClient::DescribeContact, request);
  }
 
  template <typename DescribeContactRequestT = Model::DescribeContactRequest>
  void DescribeContactAsync(const DescribeContactRequestT& request, const DescribeContactResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::DescribeContact, request, handler, context);
  }
 
  virtual Model::DescribeEphemerisOutcome DescribeEphemeris(const Model::DescribeEphemerisRequest& request) const;
 
  template <typename DescribeEphemerisRequestT = Model::DescribeEphemerisRequest>
  Model::DescribeEphemerisOutcomeCallable DescribeEphemerisCallable(const DescribeEphemerisRequestT& request) const {
    return SubmitCallable(&GroundStationClient::DescribeEphemeris, request);
  }
 
  template <typename DescribeEphemerisRequestT = Model::DescribeEphemerisRequest>
  void DescribeEphemerisAsync(const DescribeEphemerisRequestT& request, const DescribeEphemerisResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::DescribeEphemeris, request, handler, context);
  }
 
  virtual Model::GetAgentConfigurationOutcome GetAgentConfiguration(const Model::GetAgentConfigurationRequest& request) const;
 
  template <typename GetAgentConfigurationRequestT = Model::GetAgentConfigurationRequest>
  Model::GetAgentConfigurationOutcomeCallable GetAgentConfigurationCallable(const GetAgentConfigurationRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetAgentConfiguration, request);
  }
 
  template <typename GetAgentConfigurationRequestT = Model::GetAgentConfigurationRequest>
  void GetAgentConfigurationAsync(const GetAgentConfigurationRequestT& request, const GetAgentConfigurationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetAgentConfiguration, request, handler, context);
  }
 
  virtual Model::GetAgentTaskResponseUrlOutcome GetAgentTaskResponseUrl(const Model::GetAgentTaskResponseUrlRequest& request) const;
 
  template <typename GetAgentTaskResponseUrlRequestT = Model::GetAgentTaskResponseUrlRequest>
  Model::GetAgentTaskResponseUrlOutcomeCallable GetAgentTaskResponseUrlCallable(const GetAgentTaskResponseUrlRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetAgentTaskResponseUrl, request);
  }
 
  template <typename GetAgentTaskResponseUrlRequestT = Model::GetAgentTaskResponseUrlRequest>
  void GetAgentTaskResponseUrlAsync(const GetAgentTaskResponseUrlRequestT& request,
                                    const GetAgentTaskResponseUrlResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetAgentTaskResponseUrl, request, handler, context);
  }
 
  virtual Model::GetConfigOutcome GetConfig(const Model::GetConfigRequest& request) const;
 
  template <typename GetConfigRequestT = Model::GetConfigRequest>
  Model::GetConfigOutcomeCallable GetConfigCallable(const GetConfigRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetConfig, request);
  }
 
  template <typename GetConfigRequestT = Model::GetConfigRequest>
  void GetConfigAsync(const GetConfigRequestT& request, const GetConfigResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetConfig, request, handler, context);
  }
 
  virtual Model::GetDataflowEndpointGroupOutcome GetDataflowEndpointGroup(const Model::GetDataflowEndpointGroupRequest& request) const;
 
  template <typename GetDataflowEndpointGroupRequestT = Model::GetDataflowEndpointGroupRequest>
  Model::GetDataflowEndpointGroupOutcomeCallable GetDataflowEndpointGroupCallable(const GetDataflowEndpointGroupRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetDataflowEndpointGroup, request);
  }
 
  template <typename GetDataflowEndpointGroupRequestT = Model::GetDataflowEndpointGroupRequest>
  void GetDataflowEndpointGroupAsync(const GetDataflowEndpointGroupRequestT& request,
                                     const GetDataflowEndpointGroupResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetDataflowEndpointGroup, request, handler, context);
  }
 
  virtual Model::GetMinuteUsageOutcome GetMinuteUsage(const Model::GetMinuteUsageRequest& request) const;
 
  template <typename GetMinuteUsageRequestT = Model::GetMinuteUsageRequest>
  Model::GetMinuteUsageOutcomeCallable GetMinuteUsageCallable(const GetMinuteUsageRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetMinuteUsage, request);
  }
 
  template <typename GetMinuteUsageRequestT = Model::GetMinuteUsageRequest>
  void GetMinuteUsageAsync(const GetMinuteUsageRequestT& request, const GetMinuteUsageResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetMinuteUsage, request, handler, context);
  }
 
  virtual Model::GetMissionProfileOutcome GetMissionProfile(const Model::GetMissionProfileRequest& request) const;
 
  template <typename GetMissionProfileRequestT = Model::GetMissionProfileRequest>
  Model::GetMissionProfileOutcomeCallable GetMissionProfileCallable(const GetMissionProfileRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetMissionProfile, request);
  }
 
  template <typename GetMissionProfileRequestT = Model::GetMissionProfileRequest>
  void GetMissionProfileAsync(const GetMissionProfileRequestT& request, const GetMissionProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetMissionProfile, request, handler, context);
  }
 
  virtual Model::GetSatelliteOutcome GetSatellite(const Model::GetSatelliteRequest& request) const;
 
  template <typename GetSatelliteRequestT = Model::GetSatelliteRequest>
  Model::GetSatelliteOutcomeCallable GetSatelliteCallable(const GetSatelliteRequestT& request) const {
    return SubmitCallable(&GroundStationClient::GetSatellite, request);
  }
 
  template <typename GetSatelliteRequestT = Model::GetSatelliteRequest>
  void GetSatelliteAsync(const GetSatelliteRequestT& request, const GetSatelliteResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::GetSatellite, request, handler, context);
  }
 
  virtual Model::ListConfigsOutcome ListConfigs(const Model::ListConfigsRequest& request = {}) const;
 
  template <typename ListConfigsRequestT = Model::ListConfigsRequest>
  Model::ListConfigsOutcomeCallable ListConfigsCallable(const ListConfigsRequestT& request = {}) const {
    return SubmitCallable(&GroundStationClient::ListConfigs, request);
  }
 
  template <typename ListConfigsRequestT = Model::ListConfigsRequest>
  void ListConfigsAsync(const ListConfigsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListConfigsRequestT& request = {}) const {
    return SubmitAsync(&GroundStationClient::ListConfigs, request, handler, context);
  }
 
  virtual Model::ListContactsOutcome ListContacts(const Model::ListContactsRequest& request) const;
 
  template <typename ListContactsRequestT = Model::ListContactsRequest>
  Model::ListContactsOutcomeCallable ListContactsCallable(const ListContactsRequestT& request) const {
    return SubmitCallable(&GroundStationClient::ListContacts, request);
  }
 
  template <typename ListContactsRequestT = Model::ListContactsRequest>
  void ListContactsAsync(const ListContactsRequestT& request, const ListContactsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::ListContacts, request, handler, context);
  }
 
  virtual Model::ListDataflowEndpointGroupsOutcome ListDataflowEndpointGroups(
      const Model::ListDataflowEndpointGroupsRequest& request = {}) const;
 
  template <typename ListDataflowEndpointGroupsRequestT = Model::ListDataflowEndpointGroupsRequest>
  Model::ListDataflowEndpointGroupsOutcomeCallable ListDataflowEndpointGroupsCallable(
      const ListDataflowEndpointGroupsRequestT& request = {}) const {
    return SubmitCallable(&GroundStationClient::ListDataflowEndpointGroups, request);
  }
 
  template <typename ListDataflowEndpointGroupsRequestT = Model::ListDataflowEndpointGroupsRequest>
  void ListDataflowEndpointGroupsAsync(const ListDataflowEndpointGroupsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListDataflowEndpointGroupsRequestT& request = {}) const {
    return SubmitAsync(&GroundStationClient::ListDataflowEndpointGroups, request, handler, context);
  }
 
  virtual Model::ListEphemeridesOutcome ListEphemerides(const Model::ListEphemeridesRequest& request) const;
 
  template <typename ListEphemeridesRequestT = Model::ListEphemeridesRequest>
  Model::ListEphemeridesOutcomeCallable ListEphemeridesCallable(const ListEphemeridesRequestT& request) const {
    return SubmitCallable(&GroundStationClient::ListEphemerides, request);
  }
 
  template <typename ListEphemeridesRequestT = Model::ListEphemeridesRequest>
  void ListEphemeridesAsync(const ListEphemeridesRequestT& request, const ListEphemeridesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::ListEphemerides, request, handler, context);
  }
 
  virtual Model::ListGroundStationsOutcome ListGroundStations(const Model::ListGroundStationsRequest& request = {}) const;
 
  template <typename ListGroundStationsRequestT = Model::ListGroundStationsRequest>
  Model::ListGroundStationsOutcomeCallable ListGroundStationsCallable(const ListGroundStationsRequestT& request = {}) const {
    return SubmitCallable(&GroundStationClient::ListGroundStations, request);
  }
 
  template <typename ListGroundStationsRequestT = Model::ListGroundStationsRequest>
  void ListGroundStationsAsync(const ListGroundStationsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListGroundStationsRequestT& request = {}) const {
    return SubmitAsync(&GroundStationClient::ListGroundStations, request, handler, context);
  }
 
  virtual Model::ListMissionProfilesOutcome ListMissionProfiles(const Model::ListMissionProfilesRequest& request = {}) const;
 
  template <typename ListMissionProfilesRequestT = Model::ListMissionProfilesRequest>
  Model::ListMissionProfilesOutcomeCallable ListMissionProfilesCallable(const ListMissionProfilesRequestT& request = {}) const {
    return SubmitCallable(&GroundStationClient::ListMissionProfiles, request);
  }
 
  template <typename ListMissionProfilesRequestT = Model::ListMissionProfilesRequest>
  void ListMissionProfilesAsync(const ListMissionProfilesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListMissionProfilesRequestT& request = {}) const {
    return SubmitAsync(&GroundStationClient::ListMissionProfiles, request, handler, context);
  }
 
  virtual Model::ListSatellitesOutcome ListSatellites(const Model::ListSatellitesRequest& request = {}) const;
 
  template <typename ListSatellitesRequestT = Model::ListSatellitesRequest>
  Model::ListSatellitesOutcomeCallable ListSatellitesCallable(const ListSatellitesRequestT& request = {}) const {
    return SubmitCallable(&GroundStationClient::ListSatellites, request);
  }
 
  template <typename ListSatellitesRequestT = Model::ListSatellitesRequest>
  void ListSatellitesAsync(const ListSatellitesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListSatellitesRequestT& request = {}) const {
    return SubmitAsync(&GroundStationClient::ListSatellites, 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(&GroundStationClient::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(&GroundStationClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RegisterAgentOutcome RegisterAgent(const Model::RegisterAgentRequest& request) const;
 
  template <typename RegisterAgentRequestT = Model::RegisterAgentRequest>
  Model::RegisterAgentOutcomeCallable RegisterAgentCallable(const RegisterAgentRequestT& request) const {
    return SubmitCallable(&GroundStationClient::RegisterAgent, request);
  }
 
  template <typename RegisterAgentRequestT = Model::RegisterAgentRequest>
  void RegisterAgentAsync(const RegisterAgentRequestT& request, const RegisterAgentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::RegisterAgent, request, handler, context);
  }
 
  virtual Model::ReserveContactOutcome ReserveContact(const Model::ReserveContactRequest& request) const;
 
  template <typename ReserveContactRequestT = Model::ReserveContactRequest>
  Model::ReserveContactOutcomeCallable ReserveContactCallable(const ReserveContactRequestT& request) const {
    return SubmitCallable(&GroundStationClient::ReserveContact, request);
  }
 
  template <typename ReserveContactRequestT = Model::ReserveContactRequest>
  void ReserveContactAsync(const ReserveContactRequestT& request, const ReserveContactResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::ReserveContact, 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(&GroundStationClient::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(&GroundStationClient::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(&GroundStationClient::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(&GroundStationClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAgentStatusOutcome UpdateAgentStatus(const Model::UpdateAgentStatusRequest& request) const;
 
  template <typename UpdateAgentStatusRequestT = Model::UpdateAgentStatusRequest>
  Model::UpdateAgentStatusOutcomeCallable UpdateAgentStatusCallable(const UpdateAgentStatusRequestT& request) const {
    return SubmitCallable(&GroundStationClient::UpdateAgentStatus, request);
  }
 
  template <typename UpdateAgentStatusRequestT = Model::UpdateAgentStatusRequest>
  void UpdateAgentStatusAsync(const UpdateAgentStatusRequestT& request, const UpdateAgentStatusResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::UpdateAgentStatus, request, handler, context);
  }
 
  virtual Model::UpdateConfigOutcome UpdateConfig(const Model::UpdateConfigRequest& request) const;
 
  template <typename UpdateConfigRequestT = Model::UpdateConfigRequest>
  Model::UpdateConfigOutcomeCallable UpdateConfigCallable(const UpdateConfigRequestT& request) const {
    return SubmitCallable(&GroundStationClient::UpdateConfig, request);
  }
 
  template <typename UpdateConfigRequestT = Model::UpdateConfigRequest>
  void UpdateConfigAsync(const UpdateConfigRequestT& request, const UpdateConfigResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::UpdateConfig, request, handler, context);
  }
 
  virtual Model::UpdateEphemerisOutcome UpdateEphemeris(const Model::UpdateEphemerisRequest& request) const;
 
  template <typename UpdateEphemerisRequestT = Model::UpdateEphemerisRequest>
  Model::UpdateEphemerisOutcomeCallable UpdateEphemerisCallable(const UpdateEphemerisRequestT& request) const {
    return SubmitCallable(&GroundStationClient::UpdateEphemeris, request);
  }
 
  template <typename UpdateEphemerisRequestT = Model::UpdateEphemerisRequest>
  void UpdateEphemerisAsync(const UpdateEphemerisRequestT& request, const UpdateEphemerisResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::UpdateEphemeris, request, handler, context);
  }
 
  virtual Model::UpdateMissionProfileOutcome UpdateMissionProfile(const Model::UpdateMissionProfileRequest& request) const;
 
  template <typename UpdateMissionProfileRequestT = Model::UpdateMissionProfileRequest>
  Model::UpdateMissionProfileOutcomeCallable UpdateMissionProfileCallable(const UpdateMissionProfileRequestT& request) const {
    return SubmitCallable(&GroundStationClient::UpdateMissionProfile, request);
  }
 
  template <typename UpdateMissionProfileRequestT = Model::UpdateMissionProfileRequest>
  void UpdateMissionProfileAsync(const UpdateMissionProfileRequestT& request, const UpdateMissionProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GroundStationClient::UpdateMissionProfile, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GroundStationEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GroundStationClient>;
  void init(const GroundStationClientConfiguration& clientConfiguration);
 
  GroundStationClientConfiguration m_clientConfiguration;
  std::shared_ptr<GroundStationEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GroundStation
}  // namespace Aws