GreengrassClient.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/greengrass/GreengrassPaginationBase.h>
#include <aws/greengrass/GreengrassServiceClientModel.h>
#include <aws/greengrass/Greengrass_EXPORTS.h>
 
namespace Aws {
namespace Greengrass {
class AWS_GREENGRASS_API GreengrassClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<GreengrassClient>,
                                            public GreengrassPaginationBase<GreengrassClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GreengrassClientConfiguration ClientConfigurationType;
  typedef GreengrassEndpointProvider EndpointProviderType;
 
  GreengrassClient(
      const Aws::Greengrass::GreengrassClientConfiguration& clientConfiguration = Aws::Greengrass::GreengrassClientConfiguration(),
      std::shared_ptr<GreengrassEndpointProviderBase> endpointProvider = nullptr);
 
  GreengrassClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<GreengrassEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Greengrass::GreengrassClientConfiguration& clientConfiguration = Aws::Greengrass::GreengrassClientConfiguration());
 
  GreengrassClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<GreengrassEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Greengrass::GreengrassClientConfiguration& clientConfiguration = Aws::Greengrass::GreengrassClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GreengrassClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GreengrassClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GreengrassClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GreengrassClient();
 
  virtual Model::AssociateRoleToGroupOutcome AssociateRoleToGroup(const Model::AssociateRoleToGroupRequest& request) const;
 
  template <typename AssociateRoleToGroupRequestT = Model::AssociateRoleToGroupRequest>
  Model::AssociateRoleToGroupOutcomeCallable AssociateRoleToGroupCallable(const AssociateRoleToGroupRequestT& request) const {
    return SubmitCallable(&GreengrassClient::AssociateRoleToGroup, request);
  }
 
  template <typename AssociateRoleToGroupRequestT = Model::AssociateRoleToGroupRequest>
  void AssociateRoleToGroupAsync(const AssociateRoleToGroupRequestT& request, const AssociateRoleToGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::AssociateRoleToGroup, request, handler, context);
  }
 
  virtual Model::AssociateServiceRoleToAccountOutcome AssociateServiceRoleToAccount(
      const Model::AssociateServiceRoleToAccountRequest& request) const;
 
  template <typename AssociateServiceRoleToAccountRequestT = Model::AssociateServiceRoleToAccountRequest>
  Model::AssociateServiceRoleToAccountOutcomeCallable AssociateServiceRoleToAccountCallable(
      const AssociateServiceRoleToAccountRequestT& request) const {
    return SubmitCallable(&GreengrassClient::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(&GreengrassClient::AssociateServiceRoleToAccount, request, handler, context);
  }
 
  virtual Model::CreateConnectorDefinitionOutcome CreateConnectorDefinition(
      const Model::CreateConnectorDefinitionRequest& request = {}) const;
 
  template <typename CreateConnectorDefinitionRequestT = Model::CreateConnectorDefinitionRequest>
  Model::CreateConnectorDefinitionOutcomeCallable CreateConnectorDefinitionCallable(
      const CreateConnectorDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateConnectorDefinition, request);
  }
 
  template <typename CreateConnectorDefinitionRequestT = Model::CreateConnectorDefinitionRequest>
  void CreateConnectorDefinitionAsync(const CreateConnectorDefinitionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const CreateConnectorDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateConnectorDefinition, request, handler, context);
  }
 
  virtual Model::CreateConnectorDefinitionVersionOutcome CreateConnectorDefinitionVersion(
      const Model::CreateConnectorDefinitionVersionRequest& request) const;
 
  template <typename CreateConnectorDefinitionVersionRequestT = Model::CreateConnectorDefinitionVersionRequest>
  Model::CreateConnectorDefinitionVersionOutcomeCallable CreateConnectorDefinitionVersionCallable(
      const CreateConnectorDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateConnectorDefinitionVersion, request);
  }
 
  template <typename CreateConnectorDefinitionVersionRequestT = Model::CreateConnectorDefinitionVersionRequest>
  void CreateConnectorDefinitionVersionAsync(const CreateConnectorDefinitionVersionRequestT& request,
                                             const CreateConnectorDefinitionVersionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateConnectorDefinitionVersion, request, handler, context);
  }
 
  virtual Model::CreateCoreDefinitionOutcome CreateCoreDefinition(const Model::CreateCoreDefinitionRequest& request = {}) const;
 
  template <typename CreateCoreDefinitionRequestT = Model::CreateCoreDefinitionRequest>
  Model::CreateCoreDefinitionOutcomeCallable CreateCoreDefinitionCallable(const CreateCoreDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateCoreDefinition, request);
  }
 
  template <typename CreateCoreDefinitionRequestT = Model::CreateCoreDefinitionRequest>
  void CreateCoreDefinitionAsync(const CreateCoreDefinitionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const CreateCoreDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateCoreDefinition, request, handler, context);
  }
 
  virtual Model::CreateCoreDefinitionVersionOutcome CreateCoreDefinitionVersion(
      const Model::CreateCoreDefinitionVersionRequest& request) const;
 
  template <typename CreateCoreDefinitionVersionRequestT = Model::CreateCoreDefinitionVersionRequest>
  Model::CreateCoreDefinitionVersionOutcomeCallable CreateCoreDefinitionVersionCallable(
      const CreateCoreDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateCoreDefinitionVersion, request);
  }
 
  template <typename CreateCoreDefinitionVersionRequestT = Model::CreateCoreDefinitionVersionRequest>
  void CreateCoreDefinitionVersionAsync(const CreateCoreDefinitionVersionRequestT& request,
                                        const CreateCoreDefinitionVersionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateCoreDefinitionVersion, 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(&GreengrassClient::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(&GreengrassClient::CreateDeployment, request, handler, context);
  }
 
  virtual Model::CreateDeviceDefinitionOutcome CreateDeviceDefinition(const Model::CreateDeviceDefinitionRequest& request = {}) const;
 
  template <typename CreateDeviceDefinitionRequestT = Model::CreateDeviceDefinitionRequest>
  Model::CreateDeviceDefinitionOutcomeCallable CreateDeviceDefinitionCallable(const CreateDeviceDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateDeviceDefinition, request);
  }
 
  template <typename CreateDeviceDefinitionRequestT = Model::CreateDeviceDefinitionRequest>
  void CreateDeviceDefinitionAsync(const CreateDeviceDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const CreateDeviceDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateDeviceDefinition, request, handler, context);
  }
 
  virtual Model::CreateDeviceDefinitionVersionOutcome CreateDeviceDefinitionVersion(
      const Model::CreateDeviceDefinitionVersionRequest& request) const;
 
  template <typename CreateDeviceDefinitionVersionRequestT = Model::CreateDeviceDefinitionVersionRequest>
  Model::CreateDeviceDefinitionVersionOutcomeCallable CreateDeviceDefinitionVersionCallable(
      const CreateDeviceDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateDeviceDefinitionVersion, request);
  }
 
  template <typename CreateDeviceDefinitionVersionRequestT = Model::CreateDeviceDefinitionVersionRequest>
  void CreateDeviceDefinitionVersionAsync(const CreateDeviceDefinitionVersionRequestT& request,
                                          const CreateDeviceDefinitionVersionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateDeviceDefinitionVersion, request, handler, context);
  }
 
  virtual Model::CreateFunctionDefinitionOutcome CreateFunctionDefinition(const Model::CreateFunctionDefinitionRequest& request = {}) const;
 
  template <typename CreateFunctionDefinitionRequestT = Model::CreateFunctionDefinitionRequest>
  Model::CreateFunctionDefinitionOutcomeCallable CreateFunctionDefinitionCallable(
      const CreateFunctionDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateFunctionDefinition, request);
  }
 
  template <typename CreateFunctionDefinitionRequestT = Model::CreateFunctionDefinitionRequest>
  void CreateFunctionDefinitionAsync(const CreateFunctionDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const CreateFunctionDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateFunctionDefinition, request, handler, context);
  }
 
  virtual Model::CreateFunctionDefinitionVersionOutcome CreateFunctionDefinitionVersion(
      const Model::CreateFunctionDefinitionVersionRequest& request) const;
 
  template <typename CreateFunctionDefinitionVersionRequestT = Model::CreateFunctionDefinitionVersionRequest>
  Model::CreateFunctionDefinitionVersionOutcomeCallable CreateFunctionDefinitionVersionCallable(
      const CreateFunctionDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateFunctionDefinitionVersion, request);
  }
 
  template <typename CreateFunctionDefinitionVersionRequestT = Model::CreateFunctionDefinitionVersionRequest>
  void CreateFunctionDefinitionVersionAsync(const CreateFunctionDefinitionVersionRequestT& request,
                                            const CreateFunctionDefinitionVersionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateFunctionDefinitionVersion, request, handler, context);
  }
 
  virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateGroup, request);
  }
 
  template <typename CreateGroupRequestT = Model::CreateGroupRequest>
  void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateGroup, request, handler, context);
  }
 
  virtual Model::CreateGroupCertificateAuthorityOutcome CreateGroupCertificateAuthority(
      const Model::CreateGroupCertificateAuthorityRequest& request) const;
 
  template <typename CreateGroupCertificateAuthorityRequestT = Model::CreateGroupCertificateAuthorityRequest>
  Model::CreateGroupCertificateAuthorityOutcomeCallable CreateGroupCertificateAuthorityCallable(
      const CreateGroupCertificateAuthorityRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateGroupCertificateAuthority, request);
  }
 
  template <typename CreateGroupCertificateAuthorityRequestT = Model::CreateGroupCertificateAuthorityRequest>
  void CreateGroupCertificateAuthorityAsync(const CreateGroupCertificateAuthorityRequestT& request,
                                            const CreateGroupCertificateAuthorityResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateGroupCertificateAuthority, request, handler, context);
  }
 
  virtual Model::CreateGroupVersionOutcome CreateGroupVersion(const Model::CreateGroupVersionRequest& request) const;
 
  template <typename CreateGroupVersionRequestT = Model::CreateGroupVersionRequest>
  Model::CreateGroupVersionOutcomeCallable CreateGroupVersionCallable(const CreateGroupVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateGroupVersion, request);
  }
 
  template <typename CreateGroupVersionRequestT = Model::CreateGroupVersionRequest>
  void CreateGroupVersionAsync(const CreateGroupVersionRequestT& request, const CreateGroupVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateGroupVersion, request, handler, context);
  }
 
  virtual Model::CreateLoggerDefinitionOutcome CreateLoggerDefinition(const Model::CreateLoggerDefinitionRequest& request = {}) const;
 
  template <typename CreateLoggerDefinitionRequestT = Model::CreateLoggerDefinitionRequest>
  Model::CreateLoggerDefinitionOutcomeCallable CreateLoggerDefinitionCallable(const CreateLoggerDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateLoggerDefinition, request);
  }
 
  template <typename CreateLoggerDefinitionRequestT = Model::CreateLoggerDefinitionRequest>
  void CreateLoggerDefinitionAsync(const CreateLoggerDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const CreateLoggerDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateLoggerDefinition, request, handler, context);
  }
 
  virtual Model::CreateLoggerDefinitionVersionOutcome CreateLoggerDefinitionVersion(
      const Model::CreateLoggerDefinitionVersionRequest& request) const;
 
  template <typename CreateLoggerDefinitionVersionRequestT = Model::CreateLoggerDefinitionVersionRequest>
  Model::CreateLoggerDefinitionVersionOutcomeCallable CreateLoggerDefinitionVersionCallable(
      const CreateLoggerDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateLoggerDefinitionVersion, request);
  }
 
  template <typename CreateLoggerDefinitionVersionRequestT = Model::CreateLoggerDefinitionVersionRequest>
  void CreateLoggerDefinitionVersionAsync(const CreateLoggerDefinitionVersionRequestT& request,
                                          const CreateLoggerDefinitionVersionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateLoggerDefinitionVersion, request, handler, context);
  }
 
  virtual Model::CreateResourceDefinitionOutcome CreateResourceDefinition(const Model::CreateResourceDefinitionRequest& request = {}) const;
 
  template <typename CreateResourceDefinitionRequestT = Model::CreateResourceDefinitionRequest>
  Model::CreateResourceDefinitionOutcomeCallable CreateResourceDefinitionCallable(
      const CreateResourceDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateResourceDefinition, request);
  }
 
  template <typename CreateResourceDefinitionRequestT = Model::CreateResourceDefinitionRequest>
  void CreateResourceDefinitionAsync(const CreateResourceDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const CreateResourceDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateResourceDefinition, request, handler, context);
  }
 
  virtual Model::CreateResourceDefinitionVersionOutcome CreateResourceDefinitionVersion(
      const Model::CreateResourceDefinitionVersionRequest& request) const;
 
  template <typename CreateResourceDefinitionVersionRequestT = Model::CreateResourceDefinitionVersionRequest>
  Model::CreateResourceDefinitionVersionOutcomeCallable CreateResourceDefinitionVersionCallable(
      const CreateResourceDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateResourceDefinitionVersion, request);
  }
 
  template <typename CreateResourceDefinitionVersionRequestT = Model::CreateResourceDefinitionVersionRequest>
  void CreateResourceDefinitionVersionAsync(const CreateResourceDefinitionVersionRequestT& request,
                                            const CreateResourceDefinitionVersionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateResourceDefinitionVersion, request, handler, context);
  }
 
  virtual Model::CreateSoftwareUpdateJobOutcome CreateSoftwareUpdateJob(const Model::CreateSoftwareUpdateJobRequest& request) const;
 
  template <typename CreateSoftwareUpdateJobRequestT = Model::CreateSoftwareUpdateJobRequest>
  Model::CreateSoftwareUpdateJobOutcomeCallable CreateSoftwareUpdateJobCallable(const CreateSoftwareUpdateJobRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateSoftwareUpdateJob, request);
  }
 
  template <typename CreateSoftwareUpdateJobRequestT = Model::CreateSoftwareUpdateJobRequest>
  void CreateSoftwareUpdateJobAsync(const CreateSoftwareUpdateJobRequestT& request,
                                    const CreateSoftwareUpdateJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateSoftwareUpdateJob, request, handler, context);
  }
 
  virtual Model::CreateSubscriptionDefinitionOutcome CreateSubscriptionDefinition(
      const Model::CreateSubscriptionDefinitionRequest& request = {}) const;
 
  template <typename CreateSubscriptionDefinitionRequestT = Model::CreateSubscriptionDefinitionRequest>
  Model::CreateSubscriptionDefinitionOutcomeCallable CreateSubscriptionDefinitionCallable(
      const CreateSubscriptionDefinitionRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::CreateSubscriptionDefinition, request);
  }
 
  template <typename CreateSubscriptionDefinitionRequestT = Model::CreateSubscriptionDefinitionRequest>
  void CreateSubscriptionDefinitionAsync(const CreateSubscriptionDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const CreateSubscriptionDefinitionRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::CreateSubscriptionDefinition, request, handler, context);
  }
 
  virtual Model::CreateSubscriptionDefinitionVersionOutcome CreateSubscriptionDefinitionVersion(
      const Model::CreateSubscriptionDefinitionVersionRequest& request) const;
 
  template <typename CreateSubscriptionDefinitionVersionRequestT = Model::CreateSubscriptionDefinitionVersionRequest>
  Model::CreateSubscriptionDefinitionVersionOutcomeCallable CreateSubscriptionDefinitionVersionCallable(
      const CreateSubscriptionDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::CreateSubscriptionDefinitionVersion, request);
  }
 
  template <typename CreateSubscriptionDefinitionVersionRequestT = Model::CreateSubscriptionDefinitionVersionRequest>
  void CreateSubscriptionDefinitionVersionAsync(const CreateSubscriptionDefinitionVersionRequestT& request,
                                                const CreateSubscriptionDefinitionVersionResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::CreateSubscriptionDefinitionVersion, request, handler, context);
  }
 
  virtual Model::DeleteConnectorDefinitionOutcome DeleteConnectorDefinition(const Model::DeleteConnectorDefinitionRequest& request) const;
 
  template <typename DeleteConnectorDefinitionRequestT = Model::DeleteConnectorDefinitionRequest>
  Model::DeleteConnectorDefinitionOutcomeCallable DeleteConnectorDefinitionCallable(
      const DeleteConnectorDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteConnectorDefinition, request);
  }
 
  template <typename DeleteConnectorDefinitionRequestT = Model::DeleteConnectorDefinitionRequest>
  void DeleteConnectorDefinitionAsync(const DeleteConnectorDefinitionRequestT& request,
                                      const DeleteConnectorDefinitionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteConnectorDefinition, request, handler, context);
  }
 
  virtual Model::DeleteCoreDefinitionOutcome DeleteCoreDefinition(const Model::DeleteCoreDefinitionRequest& request) const;
 
  template <typename DeleteCoreDefinitionRequestT = Model::DeleteCoreDefinitionRequest>
  Model::DeleteCoreDefinitionOutcomeCallable DeleteCoreDefinitionCallable(const DeleteCoreDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteCoreDefinition, request);
  }
 
  template <typename DeleteCoreDefinitionRequestT = Model::DeleteCoreDefinitionRequest>
  void DeleteCoreDefinitionAsync(const DeleteCoreDefinitionRequestT& request, const DeleteCoreDefinitionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteCoreDefinition, request, handler, context);
  }
 
  virtual Model::DeleteDeviceDefinitionOutcome DeleteDeviceDefinition(const Model::DeleteDeviceDefinitionRequest& request) const;
 
  template <typename DeleteDeviceDefinitionRequestT = Model::DeleteDeviceDefinitionRequest>
  Model::DeleteDeviceDefinitionOutcomeCallable DeleteDeviceDefinitionCallable(const DeleteDeviceDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteDeviceDefinition, request);
  }
 
  template <typename DeleteDeviceDefinitionRequestT = Model::DeleteDeviceDefinitionRequest>
  void DeleteDeviceDefinitionAsync(const DeleteDeviceDefinitionRequestT& request,
                                   const DeleteDeviceDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteDeviceDefinition, request, handler, context);
  }
 
  virtual Model::DeleteFunctionDefinitionOutcome DeleteFunctionDefinition(const Model::DeleteFunctionDefinitionRequest& request) const;
 
  template <typename DeleteFunctionDefinitionRequestT = Model::DeleteFunctionDefinitionRequest>
  Model::DeleteFunctionDefinitionOutcomeCallable DeleteFunctionDefinitionCallable(const DeleteFunctionDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteFunctionDefinition, request);
  }
 
  template <typename DeleteFunctionDefinitionRequestT = Model::DeleteFunctionDefinitionRequest>
  void DeleteFunctionDefinitionAsync(const DeleteFunctionDefinitionRequestT& request,
                                     const DeleteFunctionDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteFunctionDefinition, request, handler, context);
  }
 
  virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const;
 
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteGroup, request);
  }
 
  template <typename DeleteGroupRequestT = Model::DeleteGroupRequest>
  void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteGroup, request, handler, context);
  }
 
  virtual Model::DeleteLoggerDefinitionOutcome DeleteLoggerDefinition(const Model::DeleteLoggerDefinitionRequest& request) const;
 
  template <typename DeleteLoggerDefinitionRequestT = Model::DeleteLoggerDefinitionRequest>
  Model::DeleteLoggerDefinitionOutcomeCallable DeleteLoggerDefinitionCallable(const DeleteLoggerDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteLoggerDefinition, request);
  }
 
  template <typename DeleteLoggerDefinitionRequestT = Model::DeleteLoggerDefinitionRequest>
  void DeleteLoggerDefinitionAsync(const DeleteLoggerDefinitionRequestT& request,
                                   const DeleteLoggerDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteLoggerDefinition, request, handler, context);
  }
 
  virtual Model::DeleteResourceDefinitionOutcome DeleteResourceDefinition(const Model::DeleteResourceDefinitionRequest& request) const;
 
  template <typename DeleteResourceDefinitionRequestT = Model::DeleteResourceDefinitionRequest>
  Model::DeleteResourceDefinitionOutcomeCallable DeleteResourceDefinitionCallable(const DeleteResourceDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteResourceDefinition, request);
  }
 
  template <typename DeleteResourceDefinitionRequestT = Model::DeleteResourceDefinitionRequest>
  void DeleteResourceDefinitionAsync(const DeleteResourceDefinitionRequestT& request,
                                     const DeleteResourceDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteResourceDefinition, request, handler, context);
  }
 
  virtual Model::DeleteSubscriptionDefinitionOutcome DeleteSubscriptionDefinition(
      const Model::DeleteSubscriptionDefinitionRequest& request) const;
 
  template <typename DeleteSubscriptionDefinitionRequestT = Model::DeleteSubscriptionDefinitionRequest>
  Model::DeleteSubscriptionDefinitionOutcomeCallable DeleteSubscriptionDefinitionCallable(
      const DeleteSubscriptionDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DeleteSubscriptionDefinition, request);
  }
 
  template <typename DeleteSubscriptionDefinitionRequestT = Model::DeleteSubscriptionDefinitionRequest>
  void DeleteSubscriptionDefinitionAsync(const DeleteSubscriptionDefinitionRequestT& request,
                                         const DeleteSubscriptionDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DeleteSubscriptionDefinition, request, handler, context);
  }
 
  virtual Model::DisassociateRoleFromGroupOutcome DisassociateRoleFromGroup(const Model::DisassociateRoleFromGroupRequest& request) const;
 
  template <typename DisassociateRoleFromGroupRequestT = Model::DisassociateRoleFromGroupRequest>
  Model::DisassociateRoleFromGroupOutcomeCallable DisassociateRoleFromGroupCallable(
      const DisassociateRoleFromGroupRequestT& request) const {
    return SubmitCallable(&GreengrassClient::DisassociateRoleFromGroup, request);
  }
 
  template <typename DisassociateRoleFromGroupRequestT = Model::DisassociateRoleFromGroupRequest>
  void DisassociateRoleFromGroupAsync(const DisassociateRoleFromGroupRequestT& request,
                                      const DisassociateRoleFromGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::DisassociateRoleFromGroup, 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(&GreengrassClient::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(&GreengrassClient::DisassociateServiceRoleFromAccount, request, handler, context);
  }
 
  virtual Model::GetAssociatedRoleOutcome GetAssociatedRole(const Model::GetAssociatedRoleRequest& request) const;
 
  template <typename GetAssociatedRoleRequestT = Model::GetAssociatedRoleRequest>
  Model::GetAssociatedRoleOutcomeCallable GetAssociatedRoleCallable(const GetAssociatedRoleRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetAssociatedRole, request);
  }
 
  template <typename GetAssociatedRoleRequestT = Model::GetAssociatedRoleRequest>
  void GetAssociatedRoleAsync(const GetAssociatedRoleRequestT& request, const GetAssociatedRoleResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetAssociatedRole, request, handler, context);
  }
 
  virtual Model::GetBulkDeploymentStatusOutcome GetBulkDeploymentStatus(const Model::GetBulkDeploymentStatusRequest& request) const;
 
  template <typename GetBulkDeploymentStatusRequestT = Model::GetBulkDeploymentStatusRequest>
  Model::GetBulkDeploymentStatusOutcomeCallable GetBulkDeploymentStatusCallable(const GetBulkDeploymentStatusRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetBulkDeploymentStatus, request);
  }
 
  template <typename GetBulkDeploymentStatusRequestT = Model::GetBulkDeploymentStatusRequest>
  void GetBulkDeploymentStatusAsync(const GetBulkDeploymentStatusRequestT& request,
                                    const GetBulkDeploymentStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetBulkDeploymentStatus, 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(&GreengrassClient::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(&GreengrassClient::GetConnectivityInfo, request, handler, context);
  }
 
  virtual Model::GetConnectorDefinitionOutcome GetConnectorDefinition(const Model::GetConnectorDefinitionRequest& request) const;
 
  template <typename GetConnectorDefinitionRequestT = Model::GetConnectorDefinitionRequest>
  Model::GetConnectorDefinitionOutcomeCallable GetConnectorDefinitionCallable(const GetConnectorDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetConnectorDefinition, request);
  }
 
  template <typename GetConnectorDefinitionRequestT = Model::GetConnectorDefinitionRequest>
  void GetConnectorDefinitionAsync(const GetConnectorDefinitionRequestT& request,
                                   const GetConnectorDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetConnectorDefinition, request, handler, context);
  }
 
  virtual Model::GetConnectorDefinitionVersionOutcome GetConnectorDefinitionVersion(
      const Model::GetConnectorDefinitionVersionRequest& request) const;
 
  template <typename GetConnectorDefinitionVersionRequestT = Model::GetConnectorDefinitionVersionRequest>
  Model::GetConnectorDefinitionVersionOutcomeCallable GetConnectorDefinitionVersionCallable(
      const GetConnectorDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetConnectorDefinitionVersion, request);
  }
 
  template <typename GetConnectorDefinitionVersionRequestT = Model::GetConnectorDefinitionVersionRequest>
  void GetConnectorDefinitionVersionAsync(const GetConnectorDefinitionVersionRequestT& request,
                                          const GetConnectorDefinitionVersionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetConnectorDefinitionVersion, request, handler, context);
  }
 
  virtual Model::GetCoreDefinitionOutcome GetCoreDefinition(const Model::GetCoreDefinitionRequest& request) const;
 
  template <typename GetCoreDefinitionRequestT = Model::GetCoreDefinitionRequest>
  Model::GetCoreDefinitionOutcomeCallable GetCoreDefinitionCallable(const GetCoreDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetCoreDefinition, request);
  }
 
  template <typename GetCoreDefinitionRequestT = Model::GetCoreDefinitionRequest>
  void GetCoreDefinitionAsync(const GetCoreDefinitionRequestT& request, const GetCoreDefinitionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetCoreDefinition, request, handler, context);
  }
 
  virtual Model::GetCoreDefinitionVersionOutcome GetCoreDefinitionVersion(const Model::GetCoreDefinitionVersionRequest& request) const;
 
  template <typename GetCoreDefinitionVersionRequestT = Model::GetCoreDefinitionVersionRequest>
  Model::GetCoreDefinitionVersionOutcomeCallable GetCoreDefinitionVersionCallable(const GetCoreDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetCoreDefinitionVersion, request);
  }
 
  template <typename GetCoreDefinitionVersionRequestT = Model::GetCoreDefinitionVersionRequest>
  void GetCoreDefinitionVersionAsync(const GetCoreDefinitionVersionRequestT& request,
                                     const GetCoreDefinitionVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetCoreDefinitionVersion, request, handler, context);
  }
 
  virtual Model::GetDeploymentStatusOutcome GetDeploymentStatus(const Model::GetDeploymentStatusRequest& request) const;
 
  template <typename GetDeploymentStatusRequestT = Model::GetDeploymentStatusRequest>
  Model::GetDeploymentStatusOutcomeCallable GetDeploymentStatusCallable(const GetDeploymentStatusRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetDeploymentStatus, request);
  }
 
  template <typename GetDeploymentStatusRequestT = Model::GetDeploymentStatusRequest>
  void GetDeploymentStatusAsync(const GetDeploymentStatusRequestT& request, const GetDeploymentStatusResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetDeploymentStatus, request, handler, context);
  }
 
  virtual Model::GetDeviceDefinitionOutcome GetDeviceDefinition(const Model::GetDeviceDefinitionRequest& request) const;
 
  template <typename GetDeviceDefinitionRequestT = Model::GetDeviceDefinitionRequest>
  Model::GetDeviceDefinitionOutcomeCallable GetDeviceDefinitionCallable(const GetDeviceDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetDeviceDefinition, request);
  }
 
  template <typename GetDeviceDefinitionRequestT = Model::GetDeviceDefinitionRequest>
  void GetDeviceDefinitionAsync(const GetDeviceDefinitionRequestT& request, const GetDeviceDefinitionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetDeviceDefinition, request, handler, context);
  }
 
  virtual Model::GetDeviceDefinitionVersionOutcome GetDeviceDefinitionVersion(
      const Model::GetDeviceDefinitionVersionRequest& request) const;
 
  template <typename GetDeviceDefinitionVersionRequestT = Model::GetDeviceDefinitionVersionRequest>
  Model::GetDeviceDefinitionVersionOutcomeCallable GetDeviceDefinitionVersionCallable(
      const GetDeviceDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetDeviceDefinitionVersion, request);
  }
 
  template <typename GetDeviceDefinitionVersionRequestT = Model::GetDeviceDefinitionVersionRequest>
  void GetDeviceDefinitionVersionAsync(const GetDeviceDefinitionVersionRequestT& request,
                                       const GetDeviceDefinitionVersionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetDeviceDefinitionVersion, request, handler, context);
  }
 
  virtual Model::GetFunctionDefinitionOutcome GetFunctionDefinition(const Model::GetFunctionDefinitionRequest& request) const;
 
  template <typename GetFunctionDefinitionRequestT = Model::GetFunctionDefinitionRequest>
  Model::GetFunctionDefinitionOutcomeCallable GetFunctionDefinitionCallable(const GetFunctionDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetFunctionDefinition, request);
  }
 
  template <typename GetFunctionDefinitionRequestT = Model::GetFunctionDefinitionRequest>
  void GetFunctionDefinitionAsync(const GetFunctionDefinitionRequestT& request, const GetFunctionDefinitionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetFunctionDefinition, request, handler, context);
  }
 
  virtual Model::GetFunctionDefinitionVersionOutcome GetFunctionDefinitionVersion(
      const Model::GetFunctionDefinitionVersionRequest& request) const;
 
  template <typename GetFunctionDefinitionVersionRequestT = Model::GetFunctionDefinitionVersionRequest>
  Model::GetFunctionDefinitionVersionOutcomeCallable GetFunctionDefinitionVersionCallable(
      const GetFunctionDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetFunctionDefinitionVersion, request);
  }
 
  template <typename GetFunctionDefinitionVersionRequestT = Model::GetFunctionDefinitionVersionRequest>
  void GetFunctionDefinitionVersionAsync(const GetFunctionDefinitionVersionRequestT& request,
                                         const GetFunctionDefinitionVersionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetFunctionDefinitionVersion, request, handler, context);
  }
 
  virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request) const;
 
  template <typename GetGroupRequestT = Model::GetGroupRequest>
  Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetGroup, request);
  }
 
  template <typename GetGroupRequestT = Model::GetGroupRequest>
  void GetGroupAsync(const GetGroupRequestT& request, const GetGroupResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetGroup, request, handler, context);
  }
 
  virtual Model::GetGroupCertificateAuthorityOutcome GetGroupCertificateAuthority(
      const Model::GetGroupCertificateAuthorityRequest& request) const;
 
  template <typename GetGroupCertificateAuthorityRequestT = Model::GetGroupCertificateAuthorityRequest>
  Model::GetGroupCertificateAuthorityOutcomeCallable GetGroupCertificateAuthorityCallable(
      const GetGroupCertificateAuthorityRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetGroupCertificateAuthority, request);
  }
 
  template <typename GetGroupCertificateAuthorityRequestT = Model::GetGroupCertificateAuthorityRequest>
  void GetGroupCertificateAuthorityAsync(const GetGroupCertificateAuthorityRequestT& request,
                                         const GetGroupCertificateAuthorityResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetGroupCertificateAuthority, request, handler, context);
  }
 
  virtual Model::GetGroupCertificateConfigurationOutcome GetGroupCertificateConfiguration(
      const Model::GetGroupCertificateConfigurationRequest& request) const;
 
  template <typename GetGroupCertificateConfigurationRequestT = Model::GetGroupCertificateConfigurationRequest>
  Model::GetGroupCertificateConfigurationOutcomeCallable GetGroupCertificateConfigurationCallable(
      const GetGroupCertificateConfigurationRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetGroupCertificateConfiguration, request);
  }
 
  template <typename GetGroupCertificateConfigurationRequestT = Model::GetGroupCertificateConfigurationRequest>
  void GetGroupCertificateConfigurationAsync(const GetGroupCertificateConfigurationRequestT& request,
                                             const GetGroupCertificateConfigurationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetGroupCertificateConfiguration, request, handler, context);
  }
 
  virtual Model::GetGroupVersionOutcome GetGroupVersion(const Model::GetGroupVersionRequest& request) const;
 
  template <typename GetGroupVersionRequestT = Model::GetGroupVersionRequest>
  Model::GetGroupVersionOutcomeCallable GetGroupVersionCallable(const GetGroupVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetGroupVersion, request);
  }
 
  template <typename GetGroupVersionRequestT = Model::GetGroupVersionRequest>
  void GetGroupVersionAsync(const GetGroupVersionRequestT& request, const GetGroupVersionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetGroupVersion, request, handler, context);
  }
 
  virtual Model::GetLoggerDefinitionOutcome GetLoggerDefinition(const Model::GetLoggerDefinitionRequest& request) const;
 
  template <typename GetLoggerDefinitionRequestT = Model::GetLoggerDefinitionRequest>
  Model::GetLoggerDefinitionOutcomeCallable GetLoggerDefinitionCallable(const GetLoggerDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetLoggerDefinition, request);
  }
 
  template <typename GetLoggerDefinitionRequestT = Model::GetLoggerDefinitionRequest>
  void GetLoggerDefinitionAsync(const GetLoggerDefinitionRequestT& request, const GetLoggerDefinitionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetLoggerDefinition, request, handler, context);
  }
 
  virtual Model::GetLoggerDefinitionVersionOutcome GetLoggerDefinitionVersion(
      const Model::GetLoggerDefinitionVersionRequest& request) const;
 
  template <typename GetLoggerDefinitionVersionRequestT = Model::GetLoggerDefinitionVersionRequest>
  Model::GetLoggerDefinitionVersionOutcomeCallable GetLoggerDefinitionVersionCallable(
      const GetLoggerDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetLoggerDefinitionVersion, request);
  }
 
  template <typename GetLoggerDefinitionVersionRequestT = Model::GetLoggerDefinitionVersionRequest>
  void GetLoggerDefinitionVersionAsync(const GetLoggerDefinitionVersionRequestT& request,
                                       const GetLoggerDefinitionVersionResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetLoggerDefinitionVersion, request, handler, context);
  }
 
  virtual Model::GetResourceDefinitionOutcome GetResourceDefinition(const Model::GetResourceDefinitionRequest& request) const;
 
  template <typename GetResourceDefinitionRequestT = Model::GetResourceDefinitionRequest>
  Model::GetResourceDefinitionOutcomeCallable GetResourceDefinitionCallable(const GetResourceDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetResourceDefinition, request);
  }
 
  template <typename GetResourceDefinitionRequestT = Model::GetResourceDefinitionRequest>
  void GetResourceDefinitionAsync(const GetResourceDefinitionRequestT& request, const GetResourceDefinitionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetResourceDefinition, request, handler, context);
  }
 
  virtual Model::GetResourceDefinitionVersionOutcome GetResourceDefinitionVersion(
      const Model::GetResourceDefinitionVersionRequest& request) const;
 
  template <typename GetResourceDefinitionVersionRequestT = Model::GetResourceDefinitionVersionRequest>
  Model::GetResourceDefinitionVersionOutcomeCallable GetResourceDefinitionVersionCallable(
      const GetResourceDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetResourceDefinitionVersion, request);
  }
 
  template <typename GetResourceDefinitionVersionRequestT = Model::GetResourceDefinitionVersionRequest>
  void GetResourceDefinitionVersionAsync(const GetResourceDefinitionVersionRequestT& request,
                                         const GetResourceDefinitionVersionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetResourceDefinitionVersion, 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(&GreengrassClient::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(&GreengrassClient::GetServiceRoleForAccount, request, handler, context);
  }
 
  virtual Model::GetSubscriptionDefinitionOutcome GetSubscriptionDefinition(const Model::GetSubscriptionDefinitionRequest& request) const;
 
  template <typename GetSubscriptionDefinitionRequestT = Model::GetSubscriptionDefinitionRequest>
  Model::GetSubscriptionDefinitionOutcomeCallable GetSubscriptionDefinitionCallable(
      const GetSubscriptionDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetSubscriptionDefinition, request);
  }
 
  template <typename GetSubscriptionDefinitionRequestT = Model::GetSubscriptionDefinitionRequest>
  void GetSubscriptionDefinitionAsync(const GetSubscriptionDefinitionRequestT& request,
                                      const GetSubscriptionDefinitionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetSubscriptionDefinition, request, handler, context);
  }
 
  virtual Model::GetSubscriptionDefinitionVersionOutcome GetSubscriptionDefinitionVersion(
      const Model::GetSubscriptionDefinitionVersionRequest& request) const;
 
  template <typename GetSubscriptionDefinitionVersionRequestT = Model::GetSubscriptionDefinitionVersionRequest>
  Model::GetSubscriptionDefinitionVersionOutcomeCallable GetSubscriptionDefinitionVersionCallable(
      const GetSubscriptionDefinitionVersionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetSubscriptionDefinitionVersion, request);
  }
 
  template <typename GetSubscriptionDefinitionVersionRequestT = Model::GetSubscriptionDefinitionVersionRequest>
  void GetSubscriptionDefinitionVersionAsync(const GetSubscriptionDefinitionVersionRequestT& request,
                                             const GetSubscriptionDefinitionVersionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetSubscriptionDefinitionVersion, request, handler, context);
  }
 
  virtual Model::GetThingRuntimeConfigurationOutcome GetThingRuntimeConfiguration(
      const Model::GetThingRuntimeConfigurationRequest& request) const;
 
  template <typename GetThingRuntimeConfigurationRequestT = Model::GetThingRuntimeConfigurationRequest>
  Model::GetThingRuntimeConfigurationOutcomeCallable GetThingRuntimeConfigurationCallable(
      const GetThingRuntimeConfigurationRequestT& request) const {
    return SubmitCallable(&GreengrassClient::GetThingRuntimeConfiguration, request);
  }
 
  template <typename GetThingRuntimeConfigurationRequestT = Model::GetThingRuntimeConfigurationRequest>
  void GetThingRuntimeConfigurationAsync(const GetThingRuntimeConfigurationRequestT& request,
                                         const GetThingRuntimeConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::GetThingRuntimeConfiguration, request, handler, context);
  }
 
  virtual Model::ListBulkDeploymentDetailedReportsOutcome ListBulkDeploymentDetailedReports(
      const Model::ListBulkDeploymentDetailedReportsRequest& request) const;
 
  template <typename ListBulkDeploymentDetailedReportsRequestT = Model::ListBulkDeploymentDetailedReportsRequest>
  Model::ListBulkDeploymentDetailedReportsOutcomeCallable ListBulkDeploymentDetailedReportsCallable(
      const ListBulkDeploymentDetailedReportsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListBulkDeploymentDetailedReports, request);
  }
 
  template <typename ListBulkDeploymentDetailedReportsRequestT = Model::ListBulkDeploymentDetailedReportsRequest>
  void ListBulkDeploymentDetailedReportsAsync(const ListBulkDeploymentDetailedReportsRequestT& request,
                                              const ListBulkDeploymentDetailedReportsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListBulkDeploymentDetailedReports, request, handler, context);
  }
 
  virtual Model::ListBulkDeploymentsOutcome ListBulkDeployments(const Model::ListBulkDeploymentsRequest& request = {}) const;
 
  template <typename ListBulkDeploymentsRequestT = Model::ListBulkDeploymentsRequest>
  Model::ListBulkDeploymentsOutcomeCallable ListBulkDeploymentsCallable(const ListBulkDeploymentsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListBulkDeployments, request);
  }
 
  template <typename ListBulkDeploymentsRequestT = Model::ListBulkDeploymentsRequest>
  void ListBulkDeploymentsAsync(const ListBulkDeploymentsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListBulkDeploymentsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListBulkDeployments, request, handler, context);
  }
 
  virtual Model::ListConnectorDefinitionVersionsOutcome ListConnectorDefinitionVersions(
      const Model::ListConnectorDefinitionVersionsRequest& request) const;
 
  template <typename ListConnectorDefinitionVersionsRequestT = Model::ListConnectorDefinitionVersionsRequest>
  Model::ListConnectorDefinitionVersionsOutcomeCallable ListConnectorDefinitionVersionsCallable(
      const ListConnectorDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListConnectorDefinitionVersions, request);
  }
 
  template <typename ListConnectorDefinitionVersionsRequestT = Model::ListConnectorDefinitionVersionsRequest>
  void ListConnectorDefinitionVersionsAsync(const ListConnectorDefinitionVersionsRequestT& request,
                                            const ListConnectorDefinitionVersionsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListConnectorDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListConnectorDefinitionsOutcome ListConnectorDefinitions(const Model::ListConnectorDefinitionsRequest& request = {}) const;
 
  template <typename ListConnectorDefinitionsRequestT = Model::ListConnectorDefinitionsRequest>
  Model::ListConnectorDefinitionsOutcomeCallable ListConnectorDefinitionsCallable(
      const ListConnectorDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListConnectorDefinitions, request);
  }
 
  template <typename ListConnectorDefinitionsRequestT = Model::ListConnectorDefinitionsRequest>
  void ListConnectorDefinitionsAsync(const ListConnectorDefinitionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListConnectorDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListConnectorDefinitions, request, handler, context);
  }
 
  virtual Model::ListCoreDefinitionVersionsOutcome ListCoreDefinitionVersions(
      const Model::ListCoreDefinitionVersionsRequest& request) const;
 
  template <typename ListCoreDefinitionVersionsRequestT = Model::ListCoreDefinitionVersionsRequest>
  Model::ListCoreDefinitionVersionsOutcomeCallable ListCoreDefinitionVersionsCallable(
      const ListCoreDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListCoreDefinitionVersions, request);
  }
 
  template <typename ListCoreDefinitionVersionsRequestT = Model::ListCoreDefinitionVersionsRequest>
  void ListCoreDefinitionVersionsAsync(const ListCoreDefinitionVersionsRequestT& request,
                                       const ListCoreDefinitionVersionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListCoreDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListCoreDefinitionsOutcome ListCoreDefinitions(const Model::ListCoreDefinitionsRequest& request = {}) const;
 
  template <typename ListCoreDefinitionsRequestT = Model::ListCoreDefinitionsRequest>
  Model::ListCoreDefinitionsOutcomeCallable ListCoreDefinitionsCallable(const ListCoreDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListCoreDefinitions, request);
  }
 
  template <typename ListCoreDefinitionsRequestT = Model::ListCoreDefinitionsRequest>
  void ListCoreDefinitionsAsync(const ListCoreDefinitionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListCoreDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListCoreDefinitions, 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(&GreengrassClient::ListDeployments, request);
  }
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  void ListDeploymentsAsync(const ListDeploymentsRequestT& request, const ListDeploymentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListDeployments, request, handler, context);
  }
 
  virtual Model::ListDeviceDefinitionVersionsOutcome ListDeviceDefinitionVersions(
      const Model::ListDeviceDefinitionVersionsRequest& request) const;
 
  template <typename ListDeviceDefinitionVersionsRequestT = Model::ListDeviceDefinitionVersionsRequest>
  Model::ListDeviceDefinitionVersionsOutcomeCallable ListDeviceDefinitionVersionsCallable(
      const ListDeviceDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListDeviceDefinitionVersions, request);
  }
 
  template <typename ListDeviceDefinitionVersionsRequestT = Model::ListDeviceDefinitionVersionsRequest>
  void ListDeviceDefinitionVersionsAsync(const ListDeviceDefinitionVersionsRequestT& request,
                                         const ListDeviceDefinitionVersionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListDeviceDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListDeviceDefinitionsOutcome ListDeviceDefinitions(const Model::ListDeviceDefinitionsRequest& request = {}) const;
 
  template <typename ListDeviceDefinitionsRequestT = Model::ListDeviceDefinitionsRequest>
  Model::ListDeviceDefinitionsOutcomeCallable ListDeviceDefinitionsCallable(const ListDeviceDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListDeviceDefinitions, request);
  }
 
  template <typename ListDeviceDefinitionsRequestT = Model::ListDeviceDefinitionsRequest>
  void ListDeviceDefinitionsAsync(const ListDeviceDefinitionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListDeviceDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListDeviceDefinitions, request, handler, context);
  }
 
  virtual Model::ListFunctionDefinitionVersionsOutcome ListFunctionDefinitionVersions(
      const Model::ListFunctionDefinitionVersionsRequest& request) const;
 
  template <typename ListFunctionDefinitionVersionsRequestT = Model::ListFunctionDefinitionVersionsRequest>
  Model::ListFunctionDefinitionVersionsOutcomeCallable ListFunctionDefinitionVersionsCallable(
      const ListFunctionDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListFunctionDefinitionVersions, request);
  }
 
  template <typename ListFunctionDefinitionVersionsRequestT = Model::ListFunctionDefinitionVersionsRequest>
  void ListFunctionDefinitionVersionsAsync(const ListFunctionDefinitionVersionsRequestT& request,
                                           const ListFunctionDefinitionVersionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListFunctionDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListFunctionDefinitionsOutcome ListFunctionDefinitions(const Model::ListFunctionDefinitionsRequest& request = {}) const;
 
  template <typename ListFunctionDefinitionsRequestT = Model::ListFunctionDefinitionsRequest>
  Model::ListFunctionDefinitionsOutcomeCallable ListFunctionDefinitionsCallable(const ListFunctionDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListFunctionDefinitions, request);
  }
 
  template <typename ListFunctionDefinitionsRequestT = Model::ListFunctionDefinitionsRequest>
  void ListFunctionDefinitionsAsync(const ListFunctionDefinitionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListFunctionDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListFunctionDefinitions, request, handler, context);
  }
 
  virtual Model::ListGroupCertificateAuthoritiesOutcome ListGroupCertificateAuthorities(
      const Model::ListGroupCertificateAuthoritiesRequest& request) const;
 
  template <typename ListGroupCertificateAuthoritiesRequestT = Model::ListGroupCertificateAuthoritiesRequest>
  Model::ListGroupCertificateAuthoritiesOutcomeCallable ListGroupCertificateAuthoritiesCallable(
      const ListGroupCertificateAuthoritiesRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListGroupCertificateAuthorities, request);
  }
 
  template <typename ListGroupCertificateAuthoritiesRequestT = Model::ListGroupCertificateAuthoritiesRequest>
  void ListGroupCertificateAuthoritiesAsync(const ListGroupCertificateAuthoritiesRequestT& request,
                                            const ListGroupCertificateAuthoritiesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListGroupCertificateAuthorities, request, handler, context);
  }
 
  virtual Model::ListGroupVersionsOutcome ListGroupVersions(const Model::ListGroupVersionsRequest& request) const;
 
  template <typename ListGroupVersionsRequestT = Model::ListGroupVersionsRequest>
  Model::ListGroupVersionsOutcomeCallable ListGroupVersionsCallable(const ListGroupVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListGroupVersions, request);
  }
 
  template <typename ListGroupVersionsRequestT = Model::ListGroupVersionsRequest>
  void ListGroupVersionsAsync(const ListGroupVersionsRequestT& request, const ListGroupVersionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListGroupVersions, request, handler, context);
  }
 
  virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request = {}) const;
 
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListGroups, request);
  }
 
  template <typename ListGroupsRequestT = Model::ListGroupsRequest>
  void ListGroupsAsync(const ListGroupsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListGroupsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListGroups, request, handler, context);
  }
 
  virtual Model::ListLoggerDefinitionVersionsOutcome ListLoggerDefinitionVersions(
      const Model::ListLoggerDefinitionVersionsRequest& request) const;
 
  template <typename ListLoggerDefinitionVersionsRequestT = Model::ListLoggerDefinitionVersionsRequest>
  Model::ListLoggerDefinitionVersionsOutcomeCallable ListLoggerDefinitionVersionsCallable(
      const ListLoggerDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListLoggerDefinitionVersions, request);
  }
 
  template <typename ListLoggerDefinitionVersionsRequestT = Model::ListLoggerDefinitionVersionsRequest>
  void ListLoggerDefinitionVersionsAsync(const ListLoggerDefinitionVersionsRequestT& request,
                                         const ListLoggerDefinitionVersionsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListLoggerDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListLoggerDefinitionsOutcome ListLoggerDefinitions(const Model::ListLoggerDefinitionsRequest& request = {}) const;
 
  template <typename ListLoggerDefinitionsRequestT = Model::ListLoggerDefinitionsRequest>
  Model::ListLoggerDefinitionsOutcomeCallable ListLoggerDefinitionsCallable(const ListLoggerDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListLoggerDefinitions, request);
  }
 
  template <typename ListLoggerDefinitionsRequestT = Model::ListLoggerDefinitionsRequest>
  void ListLoggerDefinitionsAsync(const ListLoggerDefinitionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListLoggerDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListLoggerDefinitions, request, handler, context);
  }
 
  virtual Model::ListResourceDefinitionVersionsOutcome ListResourceDefinitionVersions(
      const Model::ListResourceDefinitionVersionsRequest& request) const;
 
  template <typename ListResourceDefinitionVersionsRequestT = Model::ListResourceDefinitionVersionsRequest>
  Model::ListResourceDefinitionVersionsOutcomeCallable ListResourceDefinitionVersionsCallable(
      const ListResourceDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListResourceDefinitionVersions, request);
  }
 
  template <typename ListResourceDefinitionVersionsRequestT = Model::ListResourceDefinitionVersionsRequest>
  void ListResourceDefinitionVersionsAsync(const ListResourceDefinitionVersionsRequestT& request,
                                           const ListResourceDefinitionVersionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListResourceDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListResourceDefinitionsOutcome ListResourceDefinitions(const Model::ListResourceDefinitionsRequest& request = {}) const;
 
  template <typename ListResourceDefinitionsRequestT = Model::ListResourceDefinitionsRequest>
  Model::ListResourceDefinitionsOutcomeCallable ListResourceDefinitionsCallable(const ListResourceDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListResourceDefinitions, request);
  }
 
  template <typename ListResourceDefinitionsRequestT = Model::ListResourceDefinitionsRequest>
  void ListResourceDefinitionsAsync(const ListResourceDefinitionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListResourceDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListResourceDefinitions, request, handler, context);
  }
 
  virtual Model::ListSubscriptionDefinitionVersionsOutcome ListSubscriptionDefinitionVersions(
      const Model::ListSubscriptionDefinitionVersionsRequest& request) const;
 
  template <typename ListSubscriptionDefinitionVersionsRequestT = Model::ListSubscriptionDefinitionVersionsRequest>
  Model::ListSubscriptionDefinitionVersionsOutcomeCallable ListSubscriptionDefinitionVersionsCallable(
      const ListSubscriptionDefinitionVersionsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ListSubscriptionDefinitionVersions, request);
  }
 
  template <typename ListSubscriptionDefinitionVersionsRequestT = Model::ListSubscriptionDefinitionVersionsRequest>
  void ListSubscriptionDefinitionVersionsAsync(const ListSubscriptionDefinitionVersionsRequestT& request,
                                               const ListSubscriptionDefinitionVersionsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ListSubscriptionDefinitionVersions, request, handler, context);
  }
 
  virtual Model::ListSubscriptionDefinitionsOutcome ListSubscriptionDefinitions(
      const Model::ListSubscriptionDefinitionsRequest& request = {}) const;
 
  template <typename ListSubscriptionDefinitionsRequestT = Model::ListSubscriptionDefinitionsRequest>
  Model::ListSubscriptionDefinitionsOutcomeCallable ListSubscriptionDefinitionsCallable(
      const ListSubscriptionDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&GreengrassClient::ListSubscriptionDefinitions, request);
  }
 
  template <typename ListSubscriptionDefinitionsRequestT = Model::ListSubscriptionDefinitionsRequest>
  void ListSubscriptionDefinitionsAsync(const ListSubscriptionDefinitionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListSubscriptionDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&GreengrassClient::ListSubscriptionDefinitions, 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(&GreengrassClient::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(&GreengrassClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ResetDeploymentsOutcome ResetDeployments(const Model::ResetDeploymentsRequest& request) const;
 
  template <typename ResetDeploymentsRequestT = Model::ResetDeploymentsRequest>
  Model::ResetDeploymentsOutcomeCallable ResetDeploymentsCallable(const ResetDeploymentsRequestT& request) const {
    return SubmitCallable(&GreengrassClient::ResetDeployments, request);
  }
 
  template <typename ResetDeploymentsRequestT = Model::ResetDeploymentsRequest>
  void ResetDeploymentsAsync(const ResetDeploymentsRequestT& request, const ResetDeploymentsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::ResetDeployments, request, handler, context);
  }
 
  virtual Model::StartBulkDeploymentOutcome StartBulkDeployment(const Model::StartBulkDeploymentRequest& request) const;
 
  template <typename StartBulkDeploymentRequestT = Model::StartBulkDeploymentRequest>
  Model::StartBulkDeploymentOutcomeCallable StartBulkDeploymentCallable(const StartBulkDeploymentRequestT& request) const {
    return SubmitCallable(&GreengrassClient::StartBulkDeployment, request);
  }
 
  template <typename StartBulkDeploymentRequestT = Model::StartBulkDeploymentRequest>
  void StartBulkDeploymentAsync(const StartBulkDeploymentRequestT& request, const StartBulkDeploymentResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::StartBulkDeployment, request, handler, context);
  }
 
  virtual Model::StopBulkDeploymentOutcome StopBulkDeployment(const Model::StopBulkDeploymentRequest& request) const;
 
  template <typename StopBulkDeploymentRequestT = Model::StopBulkDeploymentRequest>
  Model::StopBulkDeploymentOutcomeCallable StopBulkDeploymentCallable(const StopBulkDeploymentRequestT& request) const {
    return SubmitCallable(&GreengrassClient::StopBulkDeployment, request);
  }
 
  template <typename StopBulkDeploymentRequestT = Model::StopBulkDeploymentRequest>
  void StopBulkDeploymentAsync(const StopBulkDeploymentRequestT& request, const StopBulkDeploymentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::StopBulkDeployment, 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(&GreengrassClient::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(&GreengrassClient::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(&GreengrassClient::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(&GreengrassClient::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(&GreengrassClient::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(&GreengrassClient::UpdateConnectivityInfo, request, handler, context);
  }
 
  virtual Model::UpdateConnectorDefinitionOutcome UpdateConnectorDefinition(const Model::UpdateConnectorDefinitionRequest& request) const;
 
  template <typename UpdateConnectorDefinitionRequestT = Model::UpdateConnectorDefinitionRequest>
  Model::UpdateConnectorDefinitionOutcomeCallable UpdateConnectorDefinitionCallable(
      const UpdateConnectorDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateConnectorDefinition, request);
  }
 
  template <typename UpdateConnectorDefinitionRequestT = Model::UpdateConnectorDefinitionRequest>
  void UpdateConnectorDefinitionAsync(const UpdateConnectorDefinitionRequestT& request,
                                      const UpdateConnectorDefinitionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateConnectorDefinition, request, handler, context);
  }
 
  virtual Model::UpdateCoreDefinitionOutcome UpdateCoreDefinition(const Model::UpdateCoreDefinitionRequest& request) const;
 
  template <typename UpdateCoreDefinitionRequestT = Model::UpdateCoreDefinitionRequest>
  Model::UpdateCoreDefinitionOutcomeCallable UpdateCoreDefinitionCallable(const UpdateCoreDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateCoreDefinition, request);
  }
 
  template <typename UpdateCoreDefinitionRequestT = Model::UpdateCoreDefinitionRequest>
  void UpdateCoreDefinitionAsync(const UpdateCoreDefinitionRequestT& request, const UpdateCoreDefinitionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateCoreDefinition, request, handler, context);
  }
 
  virtual Model::UpdateDeviceDefinitionOutcome UpdateDeviceDefinition(const Model::UpdateDeviceDefinitionRequest& request) const;
 
  template <typename UpdateDeviceDefinitionRequestT = Model::UpdateDeviceDefinitionRequest>
  Model::UpdateDeviceDefinitionOutcomeCallable UpdateDeviceDefinitionCallable(const UpdateDeviceDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateDeviceDefinition, request);
  }
 
  template <typename UpdateDeviceDefinitionRequestT = Model::UpdateDeviceDefinitionRequest>
  void UpdateDeviceDefinitionAsync(const UpdateDeviceDefinitionRequestT& request,
                                   const UpdateDeviceDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateDeviceDefinition, request, handler, context);
  }
 
  virtual Model::UpdateFunctionDefinitionOutcome UpdateFunctionDefinition(const Model::UpdateFunctionDefinitionRequest& request) const;
 
  template <typename UpdateFunctionDefinitionRequestT = Model::UpdateFunctionDefinitionRequest>
  Model::UpdateFunctionDefinitionOutcomeCallable UpdateFunctionDefinitionCallable(const UpdateFunctionDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateFunctionDefinition, request);
  }
 
  template <typename UpdateFunctionDefinitionRequestT = Model::UpdateFunctionDefinitionRequest>
  void UpdateFunctionDefinitionAsync(const UpdateFunctionDefinitionRequestT& request,
                                     const UpdateFunctionDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateFunctionDefinition, request, handler, context);
  }
 
  virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const;
 
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateGroup, request);
  }
 
  template <typename UpdateGroupRequestT = Model::UpdateGroupRequest>
  void UpdateGroupAsync(const UpdateGroupRequestT& request, const UpdateGroupResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateGroup, request, handler, context);
  }
 
  virtual Model::UpdateGroupCertificateConfigurationOutcome UpdateGroupCertificateConfiguration(
      const Model::UpdateGroupCertificateConfigurationRequest& request) const;
 
  template <typename UpdateGroupCertificateConfigurationRequestT = Model::UpdateGroupCertificateConfigurationRequest>
  Model::UpdateGroupCertificateConfigurationOutcomeCallable UpdateGroupCertificateConfigurationCallable(
      const UpdateGroupCertificateConfigurationRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateGroupCertificateConfiguration, request);
  }
 
  template <typename UpdateGroupCertificateConfigurationRequestT = Model::UpdateGroupCertificateConfigurationRequest>
  void UpdateGroupCertificateConfigurationAsync(const UpdateGroupCertificateConfigurationRequestT& request,
                                                const UpdateGroupCertificateConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateGroupCertificateConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateLoggerDefinitionOutcome UpdateLoggerDefinition(const Model::UpdateLoggerDefinitionRequest& request) const;
 
  template <typename UpdateLoggerDefinitionRequestT = Model::UpdateLoggerDefinitionRequest>
  Model::UpdateLoggerDefinitionOutcomeCallable UpdateLoggerDefinitionCallable(const UpdateLoggerDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateLoggerDefinition, request);
  }
 
  template <typename UpdateLoggerDefinitionRequestT = Model::UpdateLoggerDefinitionRequest>
  void UpdateLoggerDefinitionAsync(const UpdateLoggerDefinitionRequestT& request,
                                   const UpdateLoggerDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateLoggerDefinition, request, handler, context);
  }
 
  virtual Model::UpdateResourceDefinitionOutcome UpdateResourceDefinition(const Model::UpdateResourceDefinitionRequest& request) const;
 
  template <typename UpdateResourceDefinitionRequestT = Model::UpdateResourceDefinitionRequest>
  Model::UpdateResourceDefinitionOutcomeCallable UpdateResourceDefinitionCallable(const UpdateResourceDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateResourceDefinition, request);
  }
 
  template <typename UpdateResourceDefinitionRequestT = Model::UpdateResourceDefinitionRequest>
  void UpdateResourceDefinitionAsync(const UpdateResourceDefinitionRequestT& request,
                                     const UpdateResourceDefinitionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateResourceDefinition, request, handler, context);
  }
 
  virtual Model::UpdateSubscriptionDefinitionOutcome UpdateSubscriptionDefinition(
      const Model::UpdateSubscriptionDefinitionRequest& request) const;
 
  template <typename UpdateSubscriptionDefinitionRequestT = Model::UpdateSubscriptionDefinitionRequest>
  Model::UpdateSubscriptionDefinitionOutcomeCallable UpdateSubscriptionDefinitionCallable(
      const UpdateSubscriptionDefinitionRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateSubscriptionDefinition, request);
  }
 
  template <typename UpdateSubscriptionDefinitionRequestT = Model::UpdateSubscriptionDefinitionRequest>
  void UpdateSubscriptionDefinitionAsync(const UpdateSubscriptionDefinitionRequestT& request,
                                         const UpdateSubscriptionDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateSubscriptionDefinition, request, handler, context);
  }
 
  virtual Model::UpdateThingRuntimeConfigurationOutcome UpdateThingRuntimeConfiguration(
      const Model::UpdateThingRuntimeConfigurationRequest& request) const;
 
  template <typename UpdateThingRuntimeConfigurationRequestT = Model::UpdateThingRuntimeConfigurationRequest>
  Model::UpdateThingRuntimeConfigurationOutcomeCallable UpdateThingRuntimeConfigurationCallable(
      const UpdateThingRuntimeConfigurationRequestT& request) const {
    return SubmitCallable(&GreengrassClient::UpdateThingRuntimeConfiguration, request);
  }
 
  template <typename UpdateThingRuntimeConfigurationRequestT = Model::UpdateThingRuntimeConfigurationRequest>
  void UpdateThingRuntimeConfigurationAsync(const UpdateThingRuntimeConfigurationRequestT& request,
                                            const UpdateThingRuntimeConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GreengrassClient::UpdateThingRuntimeConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GreengrassEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GreengrassClient>;
  void init(const GreengrassClientConfiguration& clientConfiguration);
 
  GreengrassClientConfiguration m_clientConfiguration;
  std::shared_ptr<GreengrassEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Greengrass
}  // namespace Aws