GreengrassV2Client.h

 
#pragma once
#include <aws/greengrassv2/GreengrassV2_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/greengrassv2/GreengrassV2ServiceClientModel.h>
 
namespace Aws
{
namespace GreengrassV2
{
  class AWS_GREENGRASSV2_API GreengrassV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<GreengrassV2Client>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef GreengrassV2ClientConfiguration ClientConfigurationType;
      typedef GreengrassV2EndpointProvider EndpointProviderType;
 
        GreengrassV2Client(const Aws::GreengrassV2::GreengrassV2ClientConfiguration& clientConfiguration = Aws::GreengrassV2::GreengrassV2ClientConfiguration(),
                           std::shared_ptr<GreengrassV2EndpointProviderBase> endpointProvider = nullptr);
 
        GreengrassV2Client(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<GreengrassV2EndpointProviderBase> endpointProvider = nullptr,
                           const Aws::GreengrassV2::GreengrassV2ClientConfiguration& clientConfiguration = Aws::GreengrassV2::GreengrassV2ClientConfiguration());
 
        GreengrassV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<GreengrassV2EndpointProviderBase> endpointProvider = nullptr,
                           const Aws::GreengrassV2::GreengrassV2ClientConfiguration& clientConfiguration = Aws::GreengrassV2::GreengrassV2ClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        GreengrassV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GreengrassV2Client(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GreengrassV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~GreengrassV2Client();
 
        virtual Model::AssociateServiceRoleToAccountOutcome AssociateServiceRoleToAccount(const Model::AssociateServiceRoleToAccountRequest& request) const;
 
        template<typename AssociateServiceRoleToAccountRequestT = Model::AssociateServiceRoleToAccountRequest>
        Model::AssociateServiceRoleToAccountOutcomeCallable AssociateServiceRoleToAccountCallable(const AssociateServiceRoleToAccountRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::AssociateServiceRoleToAccount, request);
        }
 
        template<typename AssociateServiceRoleToAccountRequestT = Model::AssociateServiceRoleToAccountRequest>
        void AssociateServiceRoleToAccountAsync(const AssociateServiceRoleToAccountRequestT& request, const AssociateServiceRoleToAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::AssociateServiceRoleToAccount, request, handler, context);
        }
 
        virtual Model::BatchAssociateClientDeviceWithCoreDeviceOutcome BatchAssociateClientDeviceWithCoreDevice(const Model::BatchAssociateClientDeviceWithCoreDeviceRequest& request) const;
 
        template<typename BatchAssociateClientDeviceWithCoreDeviceRequestT = Model::BatchAssociateClientDeviceWithCoreDeviceRequest>
        Model::BatchAssociateClientDeviceWithCoreDeviceOutcomeCallable BatchAssociateClientDeviceWithCoreDeviceCallable(const BatchAssociateClientDeviceWithCoreDeviceRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::BatchAssociateClientDeviceWithCoreDevice, request);
        }
 
        template<typename BatchAssociateClientDeviceWithCoreDeviceRequestT = Model::BatchAssociateClientDeviceWithCoreDeviceRequest>
        void BatchAssociateClientDeviceWithCoreDeviceAsync(const BatchAssociateClientDeviceWithCoreDeviceRequestT& request, const BatchAssociateClientDeviceWithCoreDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::BatchAssociateClientDeviceWithCoreDevice, request, handler, context);
        }
 
        virtual Model::BatchDisassociateClientDeviceFromCoreDeviceOutcome BatchDisassociateClientDeviceFromCoreDevice(const Model::BatchDisassociateClientDeviceFromCoreDeviceRequest& request) const;
 
        template<typename BatchDisassociateClientDeviceFromCoreDeviceRequestT = Model::BatchDisassociateClientDeviceFromCoreDeviceRequest>
        Model::BatchDisassociateClientDeviceFromCoreDeviceOutcomeCallable BatchDisassociateClientDeviceFromCoreDeviceCallable(const BatchDisassociateClientDeviceFromCoreDeviceRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::BatchDisassociateClientDeviceFromCoreDevice, request);
        }
 
        template<typename BatchDisassociateClientDeviceFromCoreDeviceRequestT = Model::BatchDisassociateClientDeviceFromCoreDeviceRequest>
        void BatchDisassociateClientDeviceFromCoreDeviceAsync(const BatchDisassociateClientDeviceFromCoreDeviceRequestT& request, const BatchDisassociateClientDeviceFromCoreDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::BatchDisassociateClientDeviceFromCoreDevice, request, handler, context);
        }
 
        virtual Model::CancelDeploymentOutcome CancelDeployment(const Model::CancelDeploymentRequest& request) const;
 
        template<typename CancelDeploymentRequestT = Model::CancelDeploymentRequest>
        Model::CancelDeploymentOutcomeCallable CancelDeploymentCallable(const CancelDeploymentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::CancelDeployment, request);
        }
 
        template<typename CancelDeploymentRequestT = Model::CancelDeploymentRequest>
        void CancelDeploymentAsync(const CancelDeploymentRequestT& request, const CancelDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::CancelDeployment, request, handler, context);
        }
 
        virtual Model::CreateComponentVersionOutcome CreateComponentVersion(const Model::CreateComponentVersionRequest& request = {}) const;
 
        template<typename CreateComponentVersionRequestT = Model::CreateComponentVersionRequest>
        Model::CreateComponentVersionOutcomeCallable CreateComponentVersionCallable(const CreateComponentVersionRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::CreateComponentVersion, request);
        }
 
        template<typename CreateComponentVersionRequestT = Model::CreateComponentVersionRequest>
        void CreateComponentVersionAsync(const CreateComponentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateComponentVersionRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::CreateComponentVersion, request, handler, context);
        }
 
        virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::CreateDeployment, request);
        }
 
        template<typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
        void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::CreateDeployment, request, handler, context);
        }
 
        virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const;
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::DeleteComponent, request);
        }
 
        template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
        void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::DeleteComponent, request, handler, context);
        }
 
        virtual Model::DeleteCoreDeviceOutcome DeleteCoreDevice(const Model::DeleteCoreDeviceRequest& request) const;
 
        template<typename DeleteCoreDeviceRequestT = Model::DeleteCoreDeviceRequest>
        Model::DeleteCoreDeviceOutcomeCallable DeleteCoreDeviceCallable(const DeleteCoreDeviceRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::DeleteCoreDevice, request);
        }
 
        template<typename DeleteCoreDeviceRequestT = Model::DeleteCoreDeviceRequest>
        void DeleteCoreDeviceAsync(const DeleteCoreDeviceRequestT& request, const DeleteCoreDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::DeleteCoreDevice, request, handler, context);
        }
 
        virtual Model::DeleteDeploymentOutcome DeleteDeployment(const Model::DeleteDeploymentRequest& request) const;
 
        template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
        Model::DeleteDeploymentOutcomeCallable DeleteDeploymentCallable(const DeleteDeploymentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::DeleteDeployment, request);
        }
 
        template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
        void DeleteDeploymentAsync(const DeleteDeploymentRequestT& request, const DeleteDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::DeleteDeployment, request, handler, context);
        }
 
        virtual Model::DescribeComponentOutcome DescribeComponent(const Model::DescribeComponentRequest& request) const;
 
        template<typename DescribeComponentRequestT = Model::DescribeComponentRequest>
        Model::DescribeComponentOutcomeCallable DescribeComponentCallable(const DescribeComponentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::DescribeComponent, request);
        }
 
        template<typename DescribeComponentRequestT = Model::DescribeComponentRequest>
        void DescribeComponentAsync(const DescribeComponentRequestT& request, const DescribeComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::DescribeComponent, request, handler, context);
        }
 
        virtual Model::DisassociateServiceRoleFromAccountOutcome DisassociateServiceRoleFromAccount(const Model::DisassociateServiceRoleFromAccountRequest& request = {}) const;
 
        template<typename DisassociateServiceRoleFromAccountRequestT = Model::DisassociateServiceRoleFromAccountRequest>
        Model::DisassociateServiceRoleFromAccountOutcomeCallable DisassociateServiceRoleFromAccountCallable(const DisassociateServiceRoleFromAccountRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::DisassociateServiceRoleFromAccount, request);
        }
 
        template<typename DisassociateServiceRoleFromAccountRequestT = Model::DisassociateServiceRoleFromAccountRequest>
        void DisassociateServiceRoleFromAccountAsync(const DisassociateServiceRoleFromAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateServiceRoleFromAccountRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::DisassociateServiceRoleFromAccount, request, handler, context);
        }
 
        virtual Model::GetComponentOutcome GetComponent(const Model::GetComponentRequest& request) const;
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        Model::GetComponentOutcomeCallable GetComponentCallable(const GetComponentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::GetComponent, request);
        }
 
        template<typename GetComponentRequestT = Model::GetComponentRequest>
        void GetComponentAsync(const GetComponentRequestT& request, const GetComponentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::GetComponent, request, handler, context);
        }
 
        virtual Model::GetComponentVersionArtifactOutcome GetComponentVersionArtifact(const Model::GetComponentVersionArtifactRequest& request) const;
 
        template<typename GetComponentVersionArtifactRequestT = Model::GetComponentVersionArtifactRequest>
        Model::GetComponentVersionArtifactOutcomeCallable GetComponentVersionArtifactCallable(const GetComponentVersionArtifactRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::GetComponentVersionArtifact, request);
        }
 
        template<typename GetComponentVersionArtifactRequestT = Model::GetComponentVersionArtifactRequest>
        void GetComponentVersionArtifactAsync(const GetComponentVersionArtifactRequestT& request, const GetComponentVersionArtifactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::GetComponentVersionArtifact, request, handler, context);
        }
 
        virtual Model::GetConnectivityInfoOutcome GetConnectivityInfo(const Model::GetConnectivityInfoRequest& request) const;
 
        template<typename GetConnectivityInfoRequestT = Model::GetConnectivityInfoRequest>
        Model::GetConnectivityInfoOutcomeCallable GetConnectivityInfoCallable(const GetConnectivityInfoRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::GetConnectivityInfo, request);
        }
 
        template<typename GetConnectivityInfoRequestT = Model::GetConnectivityInfoRequest>
        void GetConnectivityInfoAsync(const GetConnectivityInfoRequestT& request, const GetConnectivityInfoResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::GetConnectivityInfo, request, handler, context);
        }
 
        virtual Model::GetCoreDeviceOutcome GetCoreDevice(const Model::GetCoreDeviceRequest& request) const;
 
        template<typename GetCoreDeviceRequestT = Model::GetCoreDeviceRequest>
        Model::GetCoreDeviceOutcomeCallable GetCoreDeviceCallable(const GetCoreDeviceRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::GetCoreDevice, request);
        }
 
        template<typename GetCoreDeviceRequestT = Model::GetCoreDeviceRequest>
        void GetCoreDeviceAsync(const GetCoreDeviceRequestT& request, const GetCoreDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::GetCoreDevice, request, handler, context);
        }
 
        virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::GetDeployment, request);
        }
 
        template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
        void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::GetDeployment, request, handler, context);
        }
 
        virtual Model::GetServiceRoleForAccountOutcome GetServiceRoleForAccount(const Model::GetServiceRoleForAccountRequest& request = {}) const;
 
        template<typename GetServiceRoleForAccountRequestT = Model::GetServiceRoleForAccountRequest>
        Model::GetServiceRoleForAccountOutcomeCallable GetServiceRoleForAccountCallable(const GetServiceRoleForAccountRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::GetServiceRoleForAccount, request);
        }
 
        template<typename GetServiceRoleForAccountRequestT = Model::GetServiceRoleForAccountRequest>
        void GetServiceRoleForAccountAsync(const GetServiceRoleForAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetServiceRoleForAccountRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::GetServiceRoleForAccount, request, handler, context);
        }
 
        virtual Model::ListClientDevicesAssociatedWithCoreDeviceOutcome ListClientDevicesAssociatedWithCoreDevice(const Model::ListClientDevicesAssociatedWithCoreDeviceRequest& request) const;
 
        template<typename ListClientDevicesAssociatedWithCoreDeviceRequestT = Model::ListClientDevicesAssociatedWithCoreDeviceRequest>
        Model::ListClientDevicesAssociatedWithCoreDeviceOutcomeCallable ListClientDevicesAssociatedWithCoreDeviceCallable(const ListClientDevicesAssociatedWithCoreDeviceRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::ListClientDevicesAssociatedWithCoreDevice, request);
        }
 
        template<typename ListClientDevicesAssociatedWithCoreDeviceRequestT = Model::ListClientDevicesAssociatedWithCoreDeviceRequest>
        void ListClientDevicesAssociatedWithCoreDeviceAsync(const ListClientDevicesAssociatedWithCoreDeviceRequestT& request, const ListClientDevicesAssociatedWithCoreDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::ListClientDevicesAssociatedWithCoreDevice, request, handler, context);
        }
 
        virtual Model::ListComponentVersionsOutcome ListComponentVersions(const Model::ListComponentVersionsRequest& request) const;
 
        template<typename ListComponentVersionsRequestT = Model::ListComponentVersionsRequest>
        Model::ListComponentVersionsOutcomeCallable ListComponentVersionsCallable(const ListComponentVersionsRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::ListComponentVersions, request);
        }
 
        template<typename ListComponentVersionsRequestT = Model::ListComponentVersionsRequest>
        void ListComponentVersionsAsync(const ListComponentVersionsRequestT& request, const ListComponentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::ListComponentVersions, request, handler, context);
        }
 
        virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request = {}) const;
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::ListComponents, request);
        }
 
        template<typename ListComponentsRequestT = Model::ListComponentsRequest>
        void ListComponentsAsync(const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListComponentsRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::ListComponents, request, handler, context);
        }
 
        virtual Model::ListCoreDevicesOutcome ListCoreDevices(const Model::ListCoreDevicesRequest& request = {}) const;
 
        template<typename ListCoreDevicesRequestT = Model::ListCoreDevicesRequest>
        Model::ListCoreDevicesOutcomeCallable ListCoreDevicesCallable(const ListCoreDevicesRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::ListCoreDevices, request);
        }
 
        template<typename ListCoreDevicesRequestT = Model::ListCoreDevicesRequest>
        void ListCoreDevicesAsync(const ListCoreDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCoreDevicesRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::ListCoreDevices, request, handler, context);
        }
 
        virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request = {}) const;
 
        template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
        Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::ListDeployments, request);
        }
 
        template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
        void ListDeploymentsAsync(const ListDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeploymentsRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::ListDeployments, request, handler, context);
        }
 
        virtual Model::ListEffectiveDeploymentsOutcome ListEffectiveDeployments(const Model::ListEffectiveDeploymentsRequest& request) const;
 
        template<typename ListEffectiveDeploymentsRequestT = Model::ListEffectiveDeploymentsRequest>
        Model::ListEffectiveDeploymentsOutcomeCallable ListEffectiveDeploymentsCallable(const ListEffectiveDeploymentsRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::ListEffectiveDeployments, request);
        }
 
        template<typename ListEffectiveDeploymentsRequestT = Model::ListEffectiveDeploymentsRequest>
        void ListEffectiveDeploymentsAsync(const ListEffectiveDeploymentsRequestT& request, const ListEffectiveDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::ListEffectiveDeployments, request, handler, context);
        }
 
        virtual Model::ListInstalledComponentsOutcome ListInstalledComponents(const Model::ListInstalledComponentsRequest& request) const;
 
        template<typename ListInstalledComponentsRequestT = Model::ListInstalledComponentsRequest>
        Model::ListInstalledComponentsOutcomeCallable ListInstalledComponentsCallable(const ListInstalledComponentsRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::ListInstalledComponents, request);
        }
 
        template<typename ListInstalledComponentsRequestT = Model::ListInstalledComponentsRequest>
        void ListInstalledComponentsAsync(const ListInstalledComponentsRequestT& request, const ListInstalledComponentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::ListInstalledComponents, 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(&GreengrassV2Client::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(&GreengrassV2Client::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ResolveComponentCandidatesOutcome ResolveComponentCandidates(const Model::ResolveComponentCandidatesRequest& request = {}) const;
 
        template<typename ResolveComponentCandidatesRequestT = Model::ResolveComponentCandidatesRequest>
        Model::ResolveComponentCandidatesOutcomeCallable ResolveComponentCandidatesCallable(const ResolveComponentCandidatesRequestT& request = {}) const
        {
            return SubmitCallable(&GreengrassV2Client::ResolveComponentCandidates, request);
        }
 
        template<typename ResolveComponentCandidatesRequestT = Model::ResolveComponentCandidatesRequest>
        void ResolveComponentCandidatesAsync(const ResolveComponentCandidatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ResolveComponentCandidatesRequestT& request = {}) const
        {
            return SubmitAsync(&GreengrassV2Client::ResolveComponentCandidates, 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(&GreengrassV2Client::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(&GreengrassV2Client::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(&GreengrassV2Client::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(&GreengrassV2Client::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateConnectivityInfoOutcome UpdateConnectivityInfo(const Model::UpdateConnectivityInfoRequest& request) const;
 
        template<typename UpdateConnectivityInfoRequestT = Model::UpdateConnectivityInfoRequest>
        Model::UpdateConnectivityInfoOutcomeCallable UpdateConnectivityInfoCallable(const UpdateConnectivityInfoRequestT& request) const
        {
            return SubmitCallable(&GreengrassV2Client::UpdateConnectivityInfo, request);
        }
 
        template<typename UpdateConnectivityInfoRequestT = Model::UpdateConnectivityInfoRequest>
        void UpdateConnectivityInfoAsync(const UpdateConnectivityInfoRequestT& request, const UpdateConnectivityInfoResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GreengrassV2Client::UpdateConnectivityInfo, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GreengrassV2EndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GreengrassV2Client>;
      void init(const GreengrassV2ClientConfiguration& clientConfiguration);
 
      GreengrassV2ClientConfiguration m_clientConfiguration;
      std::shared_ptr<GreengrassV2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace GreengrassV2
} // namespace Aws