GreengrassV2Client.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/greengrassv2/GreengrassV2PaginationBase.h>
#include <aws/greengrassv2/GreengrassV2ServiceClientModel.h>
#include <aws/greengrassv2/GreengrassV2Waiter.h>
#include <aws/greengrassv2/GreengrassV2_EXPORTS.h>
 
namespace Aws {
namespace GreengrassV2 {
class AWS_GREENGRASSV2_API GreengrassV2Client : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<GreengrassV2Client>,
                                                public GreengrassV2PaginationBase<GreengrassV2Client>,
                                                public GreengrassV2Waiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GreengrassV2EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GreengrassV2Client>;
  void init(const GreengrassV2ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GreengrassV2Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  GreengrassV2ClientConfiguration m_clientConfiguration;
  std::shared_ptr<GreengrassV2EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GreengrassV2
}  // namespace Aws