GroundStationClient.h

 
#pragma once
#include <aws/groundstation/GroundStation_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/groundstation/GroundStationServiceClientModel.h>
 
namespace Aws
{
namespace GroundStation
{
  class AWS_GROUNDSTATION_API GroundStationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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