GreengrassClient.h

 
#pragma once
#include <aws/greengrass/Greengrass_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/greengrass/GreengrassServiceClientModel.h>
 
namespace Aws
{
namespace Greengrass
{
  class AWS_GREENGRASS_API GreengrassClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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