IoTManagedIntegrationsClient.h

 
#pragma once
#include <aws/iot-managed-integrations/IoTManagedIntegrations_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/iot-managed-integrations/IoTManagedIntegrationsServiceClientModel.h>
 
namespace Aws
{
namespace IoTManagedIntegrations
{
  class AWS_IOTMANAGEDINTEGRATIONS_API IoTManagedIntegrationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTManagedIntegrationsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTManagedIntegrationsClientConfiguration ClientConfigurationType;
      typedef IoTManagedIntegrationsEndpointProvider EndpointProviderType;
 
        IoTManagedIntegrationsClient(const Aws::IoTManagedIntegrations::IoTManagedIntegrationsClientConfiguration& clientConfiguration = Aws::IoTManagedIntegrations::IoTManagedIntegrationsClientConfiguration(),
                                     std::shared_ptr<IoTManagedIntegrationsEndpointProviderBase> endpointProvider = nullptr);
 
        IoTManagedIntegrationsClient(const Aws::Auth::AWSCredentials& credentials,
                                     std::shared_ptr<IoTManagedIntegrationsEndpointProviderBase> endpointProvider = nullptr,
                                     const Aws::IoTManagedIntegrations::IoTManagedIntegrationsClientConfiguration& clientConfiguration = Aws::IoTManagedIntegrations::IoTManagedIntegrationsClientConfiguration());
 
        IoTManagedIntegrationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                     std::shared_ptr<IoTManagedIntegrationsEndpointProviderBase> endpointProvider = nullptr,
                                     const Aws::IoTManagedIntegrations::IoTManagedIntegrationsClientConfiguration& clientConfiguration = Aws::IoTManagedIntegrations::IoTManagedIntegrationsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTManagedIntegrationsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTManagedIntegrationsClient(const Aws::Auth::AWSCredentials& credentials,
                                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTManagedIntegrationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTManagedIntegrationsClient();
 
        virtual Model::CreateAccountAssociationOutcome CreateAccountAssociation(const Model::CreateAccountAssociationRequest& request) const;
 
        template<typename CreateAccountAssociationRequestT = Model::CreateAccountAssociationRequest>
        Model::CreateAccountAssociationOutcomeCallable CreateAccountAssociationCallable(const CreateAccountAssociationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateAccountAssociation, request);
        }
 
        template<typename CreateAccountAssociationRequestT = Model::CreateAccountAssociationRequest>
        void CreateAccountAssociationAsync(const CreateAccountAssociationRequestT& request, const CreateAccountAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateAccountAssociation, request, handler, context);
        }
 
        virtual Model::CreateCloudConnectorOutcome CreateCloudConnector(const Model::CreateCloudConnectorRequest& request) const;
 
        template<typename CreateCloudConnectorRequestT = Model::CreateCloudConnectorRequest>
        Model::CreateCloudConnectorOutcomeCallable CreateCloudConnectorCallable(const CreateCloudConnectorRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateCloudConnector, request);
        }
 
        template<typename CreateCloudConnectorRequestT = Model::CreateCloudConnectorRequest>
        void CreateCloudConnectorAsync(const CreateCloudConnectorRequestT& request, const CreateCloudConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateCloudConnector, request, handler, context);
        }
 
        virtual Model::CreateConnectorDestinationOutcome CreateConnectorDestination(const Model::CreateConnectorDestinationRequest& request) const;
 
        template<typename CreateConnectorDestinationRequestT = Model::CreateConnectorDestinationRequest>
        Model::CreateConnectorDestinationOutcomeCallable CreateConnectorDestinationCallable(const CreateConnectorDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateConnectorDestination, request);
        }
 
        template<typename CreateConnectorDestinationRequestT = Model::CreateConnectorDestinationRequest>
        void CreateConnectorDestinationAsync(const CreateConnectorDestinationRequestT& request, const CreateConnectorDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateConnectorDestination, request, handler, context);
        }
 
        virtual Model::CreateCredentialLockerOutcome CreateCredentialLocker(const Model::CreateCredentialLockerRequest& request = {}) const;
 
        template<typename CreateCredentialLockerRequestT = Model::CreateCredentialLockerRequest>
        Model::CreateCredentialLockerOutcomeCallable CreateCredentialLockerCallable(const CreateCredentialLockerRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateCredentialLocker, request);
        }
 
        template<typename CreateCredentialLockerRequestT = Model::CreateCredentialLockerRequest>
        void CreateCredentialLockerAsync(const CreateCredentialLockerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateCredentialLockerRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateCredentialLocker, request, handler, context);
        }
 
        virtual Model::CreateDestinationOutcome CreateDestination(const Model::CreateDestinationRequest& request) const;
 
        template<typename CreateDestinationRequestT = Model::CreateDestinationRequest>
        Model::CreateDestinationOutcomeCallable CreateDestinationCallable(const CreateDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateDestination, request);
        }
 
        template<typename CreateDestinationRequestT = Model::CreateDestinationRequest>
        void CreateDestinationAsync(const CreateDestinationRequestT& request, const CreateDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateDestination, request, handler, context);
        }
 
        virtual Model::CreateEventLogConfigurationOutcome CreateEventLogConfiguration(const Model::CreateEventLogConfigurationRequest& request) const;
 
        template<typename CreateEventLogConfigurationRequestT = Model::CreateEventLogConfigurationRequest>
        Model::CreateEventLogConfigurationOutcomeCallable CreateEventLogConfigurationCallable(const CreateEventLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateEventLogConfiguration, request);
        }
 
        template<typename CreateEventLogConfigurationRequestT = Model::CreateEventLogConfigurationRequest>
        void CreateEventLogConfigurationAsync(const CreateEventLogConfigurationRequestT& request, const CreateEventLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateEventLogConfiguration, request, handler, context);
        }
 
        virtual Model::CreateManagedThingOutcome CreateManagedThing(const Model::CreateManagedThingRequest& request) const;
 
        template<typename CreateManagedThingRequestT = Model::CreateManagedThingRequest>
        Model::CreateManagedThingOutcomeCallable CreateManagedThingCallable(const CreateManagedThingRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateManagedThing, request);
        }
 
        template<typename CreateManagedThingRequestT = Model::CreateManagedThingRequest>
        void CreateManagedThingAsync(const CreateManagedThingRequestT& request, const CreateManagedThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateManagedThing, request, handler, context);
        }
 
        virtual Model::CreateNotificationConfigurationOutcome CreateNotificationConfiguration(const Model::CreateNotificationConfigurationRequest& request) const;
 
        template<typename CreateNotificationConfigurationRequestT = Model::CreateNotificationConfigurationRequest>
        Model::CreateNotificationConfigurationOutcomeCallable CreateNotificationConfigurationCallable(const CreateNotificationConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateNotificationConfiguration, request);
        }
 
        template<typename CreateNotificationConfigurationRequestT = Model::CreateNotificationConfigurationRequest>
        void CreateNotificationConfigurationAsync(const CreateNotificationConfigurationRequestT& request, const CreateNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateNotificationConfiguration, request, handler, context);
        }
 
        virtual Model::CreateOtaTaskOutcome CreateOtaTask(const Model::CreateOtaTaskRequest& request) const;
 
        template<typename CreateOtaTaskRequestT = Model::CreateOtaTaskRequest>
        Model::CreateOtaTaskOutcomeCallable CreateOtaTaskCallable(const CreateOtaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateOtaTask, request);
        }
 
        template<typename CreateOtaTaskRequestT = Model::CreateOtaTaskRequest>
        void CreateOtaTaskAsync(const CreateOtaTaskRequestT& request, const CreateOtaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateOtaTask, request, handler, context);
        }
 
        virtual Model::CreateOtaTaskConfigurationOutcome CreateOtaTaskConfiguration(const Model::CreateOtaTaskConfigurationRequest& request = {}) const;
 
        template<typename CreateOtaTaskConfigurationRequestT = Model::CreateOtaTaskConfigurationRequest>
        Model::CreateOtaTaskConfigurationOutcomeCallable CreateOtaTaskConfigurationCallable(const CreateOtaTaskConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateOtaTaskConfiguration, request);
        }
 
        template<typename CreateOtaTaskConfigurationRequestT = Model::CreateOtaTaskConfigurationRequest>
        void CreateOtaTaskConfigurationAsync(const CreateOtaTaskConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateOtaTaskConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateOtaTaskConfiguration, request, handler, context);
        }
 
        virtual Model::CreateProvisioningProfileOutcome CreateProvisioningProfile(const Model::CreateProvisioningProfileRequest& request) const;
 
        template<typename CreateProvisioningProfileRequestT = Model::CreateProvisioningProfileRequest>
        Model::CreateProvisioningProfileOutcomeCallable CreateProvisioningProfileCallable(const CreateProvisioningProfileRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::CreateProvisioningProfile, request);
        }
 
        template<typename CreateProvisioningProfileRequestT = Model::CreateProvisioningProfileRequest>
        void CreateProvisioningProfileAsync(const CreateProvisioningProfileRequestT& request, const CreateProvisioningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::CreateProvisioningProfile, request, handler, context);
        }
 
        virtual Model::DeleteAccountAssociationOutcome DeleteAccountAssociation(const Model::DeleteAccountAssociationRequest& request) const;
 
        template<typename DeleteAccountAssociationRequestT = Model::DeleteAccountAssociationRequest>
        Model::DeleteAccountAssociationOutcomeCallable DeleteAccountAssociationCallable(const DeleteAccountAssociationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteAccountAssociation, request);
        }
 
        template<typename DeleteAccountAssociationRequestT = Model::DeleteAccountAssociationRequest>
        void DeleteAccountAssociationAsync(const DeleteAccountAssociationRequestT& request, const DeleteAccountAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteAccountAssociation, request, handler, context);
        }
 
        virtual Model::DeleteCloudConnectorOutcome DeleteCloudConnector(const Model::DeleteCloudConnectorRequest& request) const;
 
        template<typename DeleteCloudConnectorRequestT = Model::DeleteCloudConnectorRequest>
        Model::DeleteCloudConnectorOutcomeCallable DeleteCloudConnectorCallable(const DeleteCloudConnectorRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteCloudConnector, request);
        }
 
        template<typename DeleteCloudConnectorRequestT = Model::DeleteCloudConnectorRequest>
        void DeleteCloudConnectorAsync(const DeleteCloudConnectorRequestT& request, const DeleteCloudConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteCloudConnector, request, handler, context);
        }
 
        virtual Model::DeleteConnectorDestinationOutcome DeleteConnectorDestination(const Model::DeleteConnectorDestinationRequest& request) const;
 
        template<typename DeleteConnectorDestinationRequestT = Model::DeleteConnectorDestinationRequest>
        Model::DeleteConnectorDestinationOutcomeCallable DeleteConnectorDestinationCallable(const DeleteConnectorDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteConnectorDestination, request);
        }
 
        template<typename DeleteConnectorDestinationRequestT = Model::DeleteConnectorDestinationRequest>
        void DeleteConnectorDestinationAsync(const DeleteConnectorDestinationRequestT& request, const DeleteConnectorDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteConnectorDestination, request, handler, context);
        }
 
        virtual Model::DeleteCredentialLockerOutcome DeleteCredentialLocker(const Model::DeleteCredentialLockerRequest& request) const;
 
        template<typename DeleteCredentialLockerRequestT = Model::DeleteCredentialLockerRequest>
        Model::DeleteCredentialLockerOutcomeCallable DeleteCredentialLockerCallable(const DeleteCredentialLockerRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteCredentialLocker, request);
        }
 
        template<typename DeleteCredentialLockerRequestT = Model::DeleteCredentialLockerRequest>
        void DeleteCredentialLockerAsync(const DeleteCredentialLockerRequestT& request, const DeleteCredentialLockerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteCredentialLocker, request, handler, context);
        }
 
        virtual Model::DeleteDestinationOutcome DeleteDestination(const Model::DeleteDestinationRequest& request) const;
 
        template<typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
        Model::DeleteDestinationOutcomeCallable DeleteDestinationCallable(const DeleteDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteDestination, request);
        }
 
        template<typename DeleteDestinationRequestT = Model::DeleteDestinationRequest>
        void DeleteDestinationAsync(const DeleteDestinationRequestT& request, const DeleteDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteDestination, request, handler, context);
        }
 
        virtual Model::DeleteEventLogConfigurationOutcome DeleteEventLogConfiguration(const Model::DeleteEventLogConfigurationRequest& request) const;
 
        template<typename DeleteEventLogConfigurationRequestT = Model::DeleteEventLogConfigurationRequest>
        Model::DeleteEventLogConfigurationOutcomeCallable DeleteEventLogConfigurationCallable(const DeleteEventLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteEventLogConfiguration, request);
        }
 
        template<typename DeleteEventLogConfigurationRequestT = Model::DeleteEventLogConfigurationRequest>
        void DeleteEventLogConfigurationAsync(const DeleteEventLogConfigurationRequestT& request, const DeleteEventLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteEventLogConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteManagedThingOutcome DeleteManagedThing(const Model::DeleteManagedThingRequest& request) const;
 
        template<typename DeleteManagedThingRequestT = Model::DeleteManagedThingRequest>
        Model::DeleteManagedThingOutcomeCallable DeleteManagedThingCallable(const DeleteManagedThingRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteManagedThing, request);
        }
 
        template<typename DeleteManagedThingRequestT = Model::DeleteManagedThingRequest>
        void DeleteManagedThingAsync(const DeleteManagedThingRequestT& request, const DeleteManagedThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteManagedThing, request, handler, context);
        }
 
        virtual Model::DeleteNotificationConfigurationOutcome DeleteNotificationConfiguration(const Model::DeleteNotificationConfigurationRequest& request) const;
 
        template<typename DeleteNotificationConfigurationRequestT = Model::DeleteNotificationConfigurationRequest>
        Model::DeleteNotificationConfigurationOutcomeCallable DeleteNotificationConfigurationCallable(const DeleteNotificationConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteNotificationConfiguration, request);
        }
 
        template<typename DeleteNotificationConfigurationRequestT = Model::DeleteNotificationConfigurationRequest>
        void DeleteNotificationConfigurationAsync(const DeleteNotificationConfigurationRequestT& request, const DeleteNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteNotificationConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteOtaTaskOutcome DeleteOtaTask(const Model::DeleteOtaTaskRequest& request) const;
 
        template<typename DeleteOtaTaskRequestT = Model::DeleteOtaTaskRequest>
        Model::DeleteOtaTaskOutcomeCallable DeleteOtaTaskCallable(const DeleteOtaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteOtaTask, request);
        }
 
        template<typename DeleteOtaTaskRequestT = Model::DeleteOtaTaskRequest>
        void DeleteOtaTaskAsync(const DeleteOtaTaskRequestT& request, const DeleteOtaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteOtaTask, request, handler, context);
        }
 
        virtual Model::DeleteOtaTaskConfigurationOutcome DeleteOtaTaskConfiguration(const Model::DeleteOtaTaskConfigurationRequest& request) const;
 
        template<typename DeleteOtaTaskConfigurationRequestT = Model::DeleteOtaTaskConfigurationRequest>
        Model::DeleteOtaTaskConfigurationOutcomeCallable DeleteOtaTaskConfigurationCallable(const DeleteOtaTaskConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteOtaTaskConfiguration, request);
        }
 
        template<typename DeleteOtaTaskConfigurationRequestT = Model::DeleteOtaTaskConfigurationRequest>
        void DeleteOtaTaskConfigurationAsync(const DeleteOtaTaskConfigurationRequestT& request, const DeleteOtaTaskConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteOtaTaskConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteProvisioningProfileOutcome DeleteProvisioningProfile(const Model::DeleteProvisioningProfileRequest& request) const;
 
        template<typename DeleteProvisioningProfileRequestT = Model::DeleteProvisioningProfileRequest>
        Model::DeleteProvisioningProfileOutcomeCallable DeleteProvisioningProfileCallable(const DeleteProvisioningProfileRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeleteProvisioningProfile, request);
        }
 
        template<typename DeleteProvisioningProfileRequestT = Model::DeleteProvisioningProfileRequest>
        void DeleteProvisioningProfileAsync(const DeleteProvisioningProfileRequestT& request, const DeleteProvisioningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeleteProvisioningProfile, request, handler, context);
        }
 
        virtual Model::DeregisterAccountAssociationOutcome DeregisterAccountAssociation(const Model::DeregisterAccountAssociationRequest& request) const;
 
        template<typename DeregisterAccountAssociationRequestT = Model::DeregisterAccountAssociationRequest>
        Model::DeregisterAccountAssociationOutcomeCallable DeregisterAccountAssociationCallable(const DeregisterAccountAssociationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::DeregisterAccountAssociation, request);
        }
 
        template<typename DeregisterAccountAssociationRequestT = Model::DeregisterAccountAssociationRequest>
        void DeregisterAccountAssociationAsync(const DeregisterAccountAssociationRequestT& request, const DeregisterAccountAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::DeregisterAccountAssociation, request, handler, context);
        }
 
        virtual Model::GetAccountAssociationOutcome GetAccountAssociation(const Model::GetAccountAssociationRequest& request) const;
 
        template<typename GetAccountAssociationRequestT = Model::GetAccountAssociationRequest>
        Model::GetAccountAssociationOutcomeCallable GetAccountAssociationCallable(const GetAccountAssociationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetAccountAssociation, request);
        }
 
        template<typename GetAccountAssociationRequestT = Model::GetAccountAssociationRequest>
        void GetAccountAssociationAsync(const GetAccountAssociationRequestT& request, const GetAccountAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetAccountAssociation, request, handler, context);
        }
 
        virtual Model::GetCloudConnectorOutcome GetCloudConnector(const Model::GetCloudConnectorRequest& request) const;
 
        template<typename GetCloudConnectorRequestT = Model::GetCloudConnectorRequest>
        Model::GetCloudConnectorOutcomeCallable GetCloudConnectorCallable(const GetCloudConnectorRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetCloudConnector, request);
        }
 
        template<typename GetCloudConnectorRequestT = Model::GetCloudConnectorRequest>
        void GetCloudConnectorAsync(const GetCloudConnectorRequestT& request, const GetCloudConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetCloudConnector, request, handler, context);
        }
 
        virtual Model::GetConnectorDestinationOutcome GetConnectorDestination(const Model::GetConnectorDestinationRequest& request) const;
 
        template<typename GetConnectorDestinationRequestT = Model::GetConnectorDestinationRequest>
        Model::GetConnectorDestinationOutcomeCallable GetConnectorDestinationCallable(const GetConnectorDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetConnectorDestination, request);
        }
 
        template<typename GetConnectorDestinationRequestT = Model::GetConnectorDestinationRequest>
        void GetConnectorDestinationAsync(const GetConnectorDestinationRequestT& request, const GetConnectorDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetConnectorDestination, request, handler, context);
        }
 
        virtual Model::GetCredentialLockerOutcome GetCredentialLocker(const Model::GetCredentialLockerRequest& request) const;
 
        template<typename GetCredentialLockerRequestT = Model::GetCredentialLockerRequest>
        Model::GetCredentialLockerOutcomeCallable GetCredentialLockerCallable(const GetCredentialLockerRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetCredentialLocker, request);
        }
 
        template<typename GetCredentialLockerRequestT = Model::GetCredentialLockerRequest>
        void GetCredentialLockerAsync(const GetCredentialLockerRequestT& request, const GetCredentialLockerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetCredentialLocker, request, handler, context);
        }
 
        virtual Model::GetCustomEndpointOutcome GetCustomEndpoint(const Model::GetCustomEndpointRequest& request = {}) const;
 
        template<typename GetCustomEndpointRequestT = Model::GetCustomEndpointRequest>
        Model::GetCustomEndpointOutcomeCallable GetCustomEndpointCallable(const GetCustomEndpointRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetCustomEndpoint, request);
        }
 
        template<typename GetCustomEndpointRequestT = Model::GetCustomEndpointRequest>
        void GetCustomEndpointAsync(const GetCustomEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCustomEndpointRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetCustomEndpoint, request, handler, context);
        }
 
        virtual Model::GetDefaultEncryptionConfigurationOutcome GetDefaultEncryptionConfiguration(const Model::GetDefaultEncryptionConfigurationRequest& request = {}) const;
 
        template<typename GetDefaultEncryptionConfigurationRequestT = Model::GetDefaultEncryptionConfigurationRequest>
        Model::GetDefaultEncryptionConfigurationOutcomeCallable GetDefaultEncryptionConfigurationCallable(const GetDefaultEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetDefaultEncryptionConfiguration, request);
        }
 
        template<typename GetDefaultEncryptionConfigurationRequestT = Model::GetDefaultEncryptionConfigurationRequest>
        void GetDefaultEncryptionConfigurationAsync(const GetDefaultEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDefaultEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetDefaultEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::GetDestinationOutcome GetDestination(const Model::GetDestinationRequest& request) const;
 
        template<typename GetDestinationRequestT = Model::GetDestinationRequest>
        Model::GetDestinationOutcomeCallable GetDestinationCallable(const GetDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetDestination, request);
        }
 
        template<typename GetDestinationRequestT = Model::GetDestinationRequest>
        void GetDestinationAsync(const GetDestinationRequestT& request, const GetDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetDestination, request, handler, context);
        }
 
        virtual Model::GetDeviceDiscoveryOutcome GetDeviceDiscovery(const Model::GetDeviceDiscoveryRequest& request) const;
 
        template<typename GetDeviceDiscoveryRequestT = Model::GetDeviceDiscoveryRequest>
        Model::GetDeviceDiscoveryOutcomeCallable GetDeviceDiscoveryCallable(const GetDeviceDiscoveryRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetDeviceDiscovery, request);
        }
 
        template<typename GetDeviceDiscoveryRequestT = Model::GetDeviceDiscoveryRequest>
        void GetDeviceDiscoveryAsync(const GetDeviceDiscoveryRequestT& request, const GetDeviceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetDeviceDiscovery, request, handler, context);
        }
 
        virtual Model::GetEventLogConfigurationOutcome GetEventLogConfiguration(const Model::GetEventLogConfigurationRequest& request) const;
 
        template<typename GetEventLogConfigurationRequestT = Model::GetEventLogConfigurationRequest>
        Model::GetEventLogConfigurationOutcomeCallable GetEventLogConfigurationCallable(const GetEventLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetEventLogConfiguration, request);
        }
 
        template<typename GetEventLogConfigurationRequestT = Model::GetEventLogConfigurationRequest>
        void GetEventLogConfigurationAsync(const GetEventLogConfigurationRequestT& request, const GetEventLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetEventLogConfiguration, request, handler, context);
        }
 
        virtual Model::GetHubConfigurationOutcome GetHubConfiguration(const Model::GetHubConfigurationRequest& request = {}) const;
 
        template<typename GetHubConfigurationRequestT = Model::GetHubConfigurationRequest>
        Model::GetHubConfigurationOutcomeCallable GetHubConfigurationCallable(const GetHubConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetHubConfiguration, request);
        }
 
        template<typename GetHubConfigurationRequestT = Model::GetHubConfigurationRequest>
        void GetHubConfigurationAsync(const GetHubConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetHubConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetHubConfiguration, request, handler, context);
        }
 
        virtual Model::GetManagedThingOutcome GetManagedThing(const Model::GetManagedThingRequest& request) const;
 
        template<typename GetManagedThingRequestT = Model::GetManagedThingRequest>
        Model::GetManagedThingOutcomeCallable GetManagedThingCallable(const GetManagedThingRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetManagedThing, request);
        }
 
        template<typename GetManagedThingRequestT = Model::GetManagedThingRequest>
        void GetManagedThingAsync(const GetManagedThingRequestT& request, const GetManagedThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetManagedThing, request, handler, context);
        }
 
        virtual Model::GetManagedThingCapabilitiesOutcome GetManagedThingCapabilities(const Model::GetManagedThingCapabilitiesRequest& request) const;
 
        template<typename GetManagedThingCapabilitiesRequestT = Model::GetManagedThingCapabilitiesRequest>
        Model::GetManagedThingCapabilitiesOutcomeCallable GetManagedThingCapabilitiesCallable(const GetManagedThingCapabilitiesRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetManagedThingCapabilities, request);
        }
 
        template<typename GetManagedThingCapabilitiesRequestT = Model::GetManagedThingCapabilitiesRequest>
        void GetManagedThingCapabilitiesAsync(const GetManagedThingCapabilitiesRequestT& request, const GetManagedThingCapabilitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetManagedThingCapabilities, request, handler, context);
        }
 
        virtual Model::GetManagedThingConnectivityDataOutcome GetManagedThingConnectivityData(const Model::GetManagedThingConnectivityDataRequest& request) const;
 
        template<typename GetManagedThingConnectivityDataRequestT = Model::GetManagedThingConnectivityDataRequest>
        Model::GetManagedThingConnectivityDataOutcomeCallable GetManagedThingConnectivityDataCallable(const GetManagedThingConnectivityDataRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetManagedThingConnectivityData, request);
        }
 
        template<typename GetManagedThingConnectivityDataRequestT = Model::GetManagedThingConnectivityDataRequest>
        void GetManagedThingConnectivityDataAsync(const GetManagedThingConnectivityDataRequestT& request, const GetManagedThingConnectivityDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetManagedThingConnectivityData, request, handler, context);
        }
 
        virtual Model::GetManagedThingMetaDataOutcome GetManagedThingMetaData(const Model::GetManagedThingMetaDataRequest& request) const;
 
        template<typename GetManagedThingMetaDataRequestT = Model::GetManagedThingMetaDataRequest>
        Model::GetManagedThingMetaDataOutcomeCallable GetManagedThingMetaDataCallable(const GetManagedThingMetaDataRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetManagedThingMetaData, request);
        }
 
        template<typename GetManagedThingMetaDataRequestT = Model::GetManagedThingMetaDataRequest>
        void GetManagedThingMetaDataAsync(const GetManagedThingMetaDataRequestT& request, const GetManagedThingMetaDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetManagedThingMetaData, request, handler, context);
        }
 
        virtual Model::GetManagedThingStateOutcome GetManagedThingState(const Model::GetManagedThingStateRequest& request) const;
 
        template<typename GetManagedThingStateRequestT = Model::GetManagedThingStateRequest>
        Model::GetManagedThingStateOutcomeCallable GetManagedThingStateCallable(const GetManagedThingStateRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetManagedThingState, request);
        }
 
        template<typename GetManagedThingStateRequestT = Model::GetManagedThingStateRequest>
        void GetManagedThingStateAsync(const GetManagedThingStateRequestT& request, const GetManagedThingStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetManagedThingState, request, handler, context);
        }
 
        virtual Model::GetNotificationConfigurationOutcome GetNotificationConfiguration(const Model::GetNotificationConfigurationRequest& request) const;
 
        template<typename GetNotificationConfigurationRequestT = Model::GetNotificationConfigurationRequest>
        Model::GetNotificationConfigurationOutcomeCallable GetNotificationConfigurationCallable(const GetNotificationConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetNotificationConfiguration, request);
        }
 
        template<typename GetNotificationConfigurationRequestT = Model::GetNotificationConfigurationRequest>
        void GetNotificationConfigurationAsync(const GetNotificationConfigurationRequestT& request, const GetNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetNotificationConfiguration, request, handler, context);
        }
 
        virtual Model::GetOtaTaskOutcome GetOtaTask(const Model::GetOtaTaskRequest& request) const;
 
        template<typename GetOtaTaskRequestT = Model::GetOtaTaskRequest>
        Model::GetOtaTaskOutcomeCallable GetOtaTaskCallable(const GetOtaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetOtaTask, request);
        }
 
        template<typename GetOtaTaskRequestT = Model::GetOtaTaskRequest>
        void GetOtaTaskAsync(const GetOtaTaskRequestT& request, const GetOtaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetOtaTask, request, handler, context);
        }
 
        virtual Model::GetOtaTaskConfigurationOutcome GetOtaTaskConfiguration(const Model::GetOtaTaskConfigurationRequest& request) const;
 
        template<typename GetOtaTaskConfigurationRequestT = Model::GetOtaTaskConfigurationRequest>
        Model::GetOtaTaskConfigurationOutcomeCallable GetOtaTaskConfigurationCallable(const GetOtaTaskConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetOtaTaskConfiguration, request);
        }
 
        template<typename GetOtaTaskConfigurationRequestT = Model::GetOtaTaskConfigurationRequest>
        void GetOtaTaskConfigurationAsync(const GetOtaTaskConfigurationRequestT& request, const GetOtaTaskConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetOtaTaskConfiguration, request, handler, context);
        }
 
        virtual Model::GetProvisioningProfileOutcome GetProvisioningProfile(const Model::GetProvisioningProfileRequest& request) const;
 
        template<typename GetProvisioningProfileRequestT = Model::GetProvisioningProfileRequest>
        Model::GetProvisioningProfileOutcomeCallable GetProvisioningProfileCallable(const GetProvisioningProfileRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetProvisioningProfile, request);
        }
 
        template<typename GetProvisioningProfileRequestT = Model::GetProvisioningProfileRequest>
        void GetProvisioningProfileAsync(const GetProvisioningProfileRequestT& request, const GetProvisioningProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetProvisioningProfile, request, handler, context);
        }
 
        virtual Model::GetRuntimeLogConfigurationOutcome GetRuntimeLogConfiguration(const Model::GetRuntimeLogConfigurationRequest& request) const;
 
        template<typename GetRuntimeLogConfigurationRequestT = Model::GetRuntimeLogConfigurationRequest>
        Model::GetRuntimeLogConfigurationOutcomeCallable GetRuntimeLogConfigurationCallable(const GetRuntimeLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetRuntimeLogConfiguration, request);
        }
 
        template<typename GetRuntimeLogConfigurationRequestT = Model::GetRuntimeLogConfigurationRequest>
        void GetRuntimeLogConfigurationAsync(const GetRuntimeLogConfigurationRequestT& request, const GetRuntimeLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetRuntimeLogConfiguration, request, handler, context);
        }
 
        virtual Model::GetSchemaVersionOutcome GetSchemaVersion(const Model::GetSchemaVersionRequest& request) const;
 
        template<typename GetSchemaVersionRequestT = Model::GetSchemaVersionRequest>
        Model::GetSchemaVersionOutcomeCallable GetSchemaVersionCallable(const GetSchemaVersionRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::GetSchemaVersion, request);
        }
 
        template<typename GetSchemaVersionRequestT = Model::GetSchemaVersionRequest>
        void GetSchemaVersionAsync(const GetSchemaVersionRequestT& request, const GetSchemaVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::GetSchemaVersion, request, handler, context);
        }
 
        virtual Model::ListAccountAssociationsOutcome ListAccountAssociations(const Model::ListAccountAssociationsRequest& request = {}) const;
 
        template<typename ListAccountAssociationsRequestT = Model::ListAccountAssociationsRequest>
        Model::ListAccountAssociationsOutcomeCallable ListAccountAssociationsCallable(const ListAccountAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListAccountAssociations, request);
        }
 
        template<typename ListAccountAssociationsRequestT = Model::ListAccountAssociationsRequest>
        void ListAccountAssociationsAsync(const ListAccountAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccountAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListAccountAssociations, request, handler, context);
        }
 
        virtual Model::ListCloudConnectorsOutcome ListCloudConnectors(const Model::ListCloudConnectorsRequest& request = {}) const;
 
        template<typename ListCloudConnectorsRequestT = Model::ListCloudConnectorsRequest>
        Model::ListCloudConnectorsOutcomeCallable ListCloudConnectorsCallable(const ListCloudConnectorsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListCloudConnectors, request);
        }
 
        template<typename ListCloudConnectorsRequestT = Model::ListCloudConnectorsRequest>
        void ListCloudConnectorsAsync(const ListCloudConnectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCloudConnectorsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListCloudConnectors, request, handler, context);
        }
 
        virtual Model::ListConnectorDestinationsOutcome ListConnectorDestinations(const Model::ListConnectorDestinationsRequest& request = {}) const;
 
        template<typename ListConnectorDestinationsRequestT = Model::ListConnectorDestinationsRequest>
        Model::ListConnectorDestinationsOutcomeCallable ListConnectorDestinationsCallable(const ListConnectorDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListConnectorDestinations, request);
        }
 
        template<typename ListConnectorDestinationsRequestT = Model::ListConnectorDestinationsRequest>
        void ListConnectorDestinationsAsync(const ListConnectorDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectorDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListConnectorDestinations, request, handler, context);
        }
 
        virtual Model::ListCredentialLockersOutcome ListCredentialLockers(const Model::ListCredentialLockersRequest& request = {}) const;
 
        template<typename ListCredentialLockersRequestT = Model::ListCredentialLockersRequest>
        Model::ListCredentialLockersOutcomeCallable ListCredentialLockersCallable(const ListCredentialLockersRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListCredentialLockers, request);
        }
 
        template<typename ListCredentialLockersRequestT = Model::ListCredentialLockersRequest>
        void ListCredentialLockersAsync(const ListCredentialLockersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCredentialLockersRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListCredentialLockers, request, handler, context);
        }
 
        virtual Model::ListDestinationsOutcome ListDestinations(const Model::ListDestinationsRequest& request = {}) const;
 
        template<typename ListDestinationsRequestT = Model::ListDestinationsRequest>
        Model::ListDestinationsOutcomeCallable ListDestinationsCallable(const ListDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListDestinations, request);
        }
 
        template<typename ListDestinationsRequestT = Model::ListDestinationsRequest>
        void ListDestinationsAsync(const ListDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListDestinations, request, handler, context);
        }
 
        virtual Model::ListDeviceDiscoveriesOutcome ListDeviceDiscoveries(const Model::ListDeviceDiscoveriesRequest& request = {}) const;
 
        template<typename ListDeviceDiscoveriesRequestT = Model::ListDeviceDiscoveriesRequest>
        Model::ListDeviceDiscoveriesOutcomeCallable ListDeviceDiscoveriesCallable(const ListDeviceDiscoveriesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListDeviceDiscoveries, request);
        }
 
        template<typename ListDeviceDiscoveriesRequestT = Model::ListDeviceDiscoveriesRequest>
        void ListDeviceDiscoveriesAsync(const ListDeviceDiscoveriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDeviceDiscoveriesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListDeviceDiscoveries, request, handler, context);
        }
 
        virtual Model::ListDiscoveredDevicesOutcome ListDiscoveredDevices(const Model::ListDiscoveredDevicesRequest& request) const;
 
        template<typename ListDiscoveredDevicesRequestT = Model::ListDiscoveredDevicesRequest>
        Model::ListDiscoveredDevicesOutcomeCallable ListDiscoveredDevicesCallable(const ListDiscoveredDevicesRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListDiscoveredDevices, request);
        }
 
        template<typename ListDiscoveredDevicesRequestT = Model::ListDiscoveredDevicesRequest>
        void ListDiscoveredDevicesAsync(const ListDiscoveredDevicesRequestT& request, const ListDiscoveredDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListDiscoveredDevices, request, handler, context);
        }
 
        virtual Model::ListEventLogConfigurationsOutcome ListEventLogConfigurations(const Model::ListEventLogConfigurationsRequest& request = {}) const;
 
        template<typename ListEventLogConfigurationsRequestT = Model::ListEventLogConfigurationsRequest>
        Model::ListEventLogConfigurationsOutcomeCallable ListEventLogConfigurationsCallable(const ListEventLogConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListEventLogConfigurations, request);
        }
 
        template<typename ListEventLogConfigurationsRequestT = Model::ListEventLogConfigurationsRequest>
        void ListEventLogConfigurationsAsync(const ListEventLogConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventLogConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListEventLogConfigurations, request, handler, context);
        }
 
        virtual Model::ListManagedThingAccountAssociationsOutcome ListManagedThingAccountAssociations(const Model::ListManagedThingAccountAssociationsRequest& request = {}) const;
 
        template<typename ListManagedThingAccountAssociationsRequestT = Model::ListManagedThingAccountAssociationsRequest>
        Model::ListManagedThingAccountAssociationsOutcomeCallable ListManagedThingAccountAssociationsCallable(const ListManagedThingAccountAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListManagedThingAccountAssociations, request);
        }
 
        template<typename ListManagedThingAccountAssociationsRequestT = Model::ListManagedThingAccountAssociationsRequest>
        void ListManagedThingAccountAssociationsAsync(const ListManagedThingAccountAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListManagedThingAccountAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListManagedThingAccountAssociations, request, handler, context);
        }
 
        virtual Model::ListManagedThingSchemasOutcome ListManagedThingSchemas(const Model::ListManagedThingSchemasRequest& request) const;
 
        template<typename ListManagedThingSchemasRequestT = Model::ListManagedThingSchemasRequest>
        Model::ListManagedThingSchemasOutcomeCallable ListManagedThingSchemasCallable(const ListManagedThingSchemasRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListManagedThingSchemas, request);
        }
 
        template<typename ListManagedThingSchemasRequestT = Model::ListManagedThingSchemasRequest>
        void ListManagedThingSchemasAsync(const ListManagedThingSchemasRequestT& request, const ListManagedThingSchemasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListManagedThingSchemas, request, handler, context);
        }
 
        virtual Model::ListManagedThingsOutcome ListManagedThings(const Model::ListManagedThingsRequest& request = {}) const;
 
        template<typename ListManagedThingsRequestT = Model::ListManagedThingsRequest>
        Model::ListManagedThingsOutcomeCallable ListManagedThingsCallable(const ListManagedThingsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListManagedThings, request);
        }
 
        template<typename ListManagedThingsRequestT = Model::ListManagedThingsRequest>
        void ListManagedThingsAsync(const ListManagedThingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListManagedThingsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListManagedThings, request, handler, context);
        }
 
        virtual Model::ListNotificationConfigurationsOutcome ListNotificationConfigurations(const Model::ListNotificationConfigurationsRequest& request = {}) const;
 
        template<typename ListNotificationConfigurationsRequestT = Model::ListNotificationConfigurationsRequest>
        Model::ListNotificationConfigurationsOutcomeCallable ListNotificationConfigurationsCallable(const ListNotificationConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListNotificationConfigurations, request);
        }
 
        template<typename ListNotificationConfigurationsRequestT = Model::ListNotificationConfigurationsRequest>
        void ListNotificationConfigurationsAsync(const ListNotificationConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNotificationConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListNotificationConfigurations, request, handler, context);
        }
 
        virtual Model::ListOtaTaskConfigurationsOutcome ListOtaTaskConfigurations(const Model::ListOtaTaskConfigurationsRequest& request = {}) const;
 
        template<typename ListOtaTaskConfigurationsRequestT = Model::ListOtaTaskConfigurationsRequest>
        Model::ListOtaTaskConfigurationsOutcomeCallable ListOtaTaskConfigurationsCallable(const ListOtaTaskConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListOtaTaskConfigurations, request);
        }
 
        template<typename ListOtaTaskConfigurationsRequestT = Model::ListOtaTaskConfigurationsRequest>
        void ListOtaTaskConfigurationsAsync(const ListOtaTaskConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOtaTaskConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListOtaTaskConfigurations, request, handler, context);
        }
 
        virtual Model::ListOtaTaskExecutionsOutcome ListOtaTaskExecutions(const Model::ListOtaTaskExecutionsRequest& request) const;
 
        template<typename ListOtaTaskExecutionsRequestT = Model::ListOtaTaskExecutionsRequest>
        Model::ListOtaTaskExecutionsOutcomeCallable ListOtaTaskExecutionsCallable(const ListOtaTaskExecutionsRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListOtaTaskExecutions, request);
        }
 
        template<typename ListOtaTaskExecutionsRequestT = Model::ListOtaTaskExecutionsRequest>
        void ListOtaTaskExecutionsAsync(const ListOtaTaskExecutionsRequestT& request, const ListOtaTaskExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListOtaTaskExecutions, request, handler, context);
        }
 
        virtual Model::ListOtaTasksOutcome ListOtaTasks(const Model::ListOtaTasksRequest& request = {}) const;
 
        template<typename ListOtaTasksRequestT = Model::ListOtaTasksRequest>
        Model::ListOtaTasksOutcomeCallable ListOtaTasksCallable(const ListOtaTasksRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListOtaTasks, request);
        }
 
        template<typename ListOtaTasksRequestT = Model::ListOtaTasksRequest>
        void ListOtaTasksAsync(const ListOtaTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOtaTasksRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListOtaTasks, request, handler, context);
        }
 
        virtual Model::ListProvisioningProfilesOutcome ListProvisioningProfiles(const Model::ListProvisioningProfilesRequest& request = {}) const;
 
        template<typename ListProvisioningProfilesRequestT = Model::ListProvisioningProfilesRequest>
        Model::ListProvisioningProfilesOutcomeCallable ListProvisioningProfilesCallable(const ListProvisioningProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListProvisioningProfiles, request);
        }
 
        template<typename ListProvisioningProfilesRequestT = Model::ListProvisioningProfilesRequest>
        void ListProvisioningProfilesAsync(const ListProvisioningProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProvisioningProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListProvisioningProfiles, request, handler, context);
        }
 
        virtual Model::ListSchemaVersionsOutcome ListSchemaVersions(const Model::ListSchemaVersionsRequest& request) const;
 
        template<typename ListSchemaVersionsRequestT = Model::ListSchemaVersionsRequest>
        Model::ListSchemaVersionsOutcomeCallable ListSchemaVersionsCallable(const ListSchemaVersionsRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ListSchemaVersions, request);
        }
 
        template<typename ListSchemaVersionsRequestT = Model::ListSchemaVersionsRequest>
        void ListSchemaVersionsAsync(const ListSchemaVersionsRequestT& request, const ListSchemaVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ListSchemaVersions, 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(&IoTManagedIntegrationsClient::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(&IoTManagedIntegrationsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutDefaultEncryptionConfigurationOutcome PutDefaultEncryptionConfiguration(const Model::PutDefaultEncryptionConfigurationRequest& request) const;
 
        template<typename PutDefaultEncryptionConfigurationRequestT = Model::PutDefaultEncryptionConfigurationRequest>
        Model::PutDefaultEncryptionConfigurationOutcomeCallable PutDefaultEncryptionConfigurationCallable(const PutDefaultEncryptionConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::PutDefaultEncryptionConfiguration, request);
        }
 
        template<typename PutDefaultEncryptionConfigurationRequestT = Model::PutDefaultEncryptionConfigurationRequest>
        void PutDefaultEncryptionConfigurationAsync(const PutDefaultEncryptionConfigurationRequestT& request, const PutDefaultEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::PutDefaultEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::PutHubConfigurationOutcome PutHubConfiguration(const Model::PutHubConfigurationRequest& request) const;
 
        template<typename PutHubConfigurationRequestT = Model::PutHubConfigurationRequest>
        Model::PutHubConfigurationOutcomeCallable PutHubConfigurationCallable(const PutHubConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::PutHubConfiguration, request);
        }
 
        template<typename PutHubConfigurationRequestT = Model::PutHubConfigurationRequest>
        void PutHubConfigurationAsync(const PutHubConfigurationRequestT& request, const PutHubConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::PutHubConfiguration, request, handler, context);
        }
 
        virtual Model::PutRuntimeLogConfigurationOutcome PutRuntimeLogConfiguration(const Model::PutRuntimeLogConfigurationRequest& request) const;
 
        template<typename PutRuntimeLogConfigurationRequestT = Model::PutRuntimeLogConfigurationRequest>
        Model::PutRuntimeLogConfigurationOutcomeCallable PutRuntimeLogConfigurationCallable(const PutRuntimeLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::PutRuntimeLogConfiguration, request);
        }
 
        template<typename PutRuntimeLogConfigurationRequestT = Model::PutRuntimeLogConfigurationRequest>
        void PutRuntimeLogConfigurationAsync(const PutRuntimeLogConfigurationRequestT& request, const PutRuntimeLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::PutRuntimeLogConfiguration, request, handler, context);
        }
 
        virtual Model::RegisterAccountAssociationOutcome RegisterAccountAssociation(const Model::RegisterAccountAssociationRequest& request) const;
 
        template<typename RegisterAccountAssociationRequestT = Model::RegisterAccountAssociationRequest>
        Model::RegisterAccountAssociationOutcomeCallable RegisterAccountAssociationCallable(const RegisterAccountAssociationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::RegisterAccountAssociation, request);
        }
 
        template<typename RegisterAccountAssociationRequestT = Model::RegisterAccountAssociationRequest>
        void RegisterAccountAssociationAsync(const RegisterAccountAssociationRequestT& request, const RegisterAccountAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::RegisterAccountAssociation, request, handler, context);
        }
 
        virtual Model::RegisterCustomEndpointOutcome RegisterCustomEndpoint(const Model::RegisterCustomEndpointRequest& request = {}) const;
 
        template<typename RegisterCustomEndpointRequestT = Model::RegisterCustomEndpointRequest>
        Model::RegisterCustomEndpointOutcomeCallable RegisterCustomEndpointCallable(const RegisterCustomEndpointRequestT& request = {}) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::RegisterCustomEndpoint, request);
        }
 
        template<typename RegisterCustomEndpointRequestT = Model::RegisterCustomEndpointRequest>
        void RegisterCustomEndpointAsync(const RegisterCustomEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterCustomEndpointRequestT& request = {}) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::RegisterCustomEndpoint, request, handler, context);
        }
 
        virtual Model::ResetRuntimeLogConfigurationOutcome ResetRuntimeLogConfiguration(const Model::ResetRuntimeLogConfigurationRequest& request) const;
 
        template<typename ResetRuntimeLogConfigurationRequestT = Model::ResetRuntimeLogConfigurationRequest>
        Model::ResetRuntimeLogConfigurationOutcomeCallable ResetRuntimeLogConfigurationCallable(const ResetRuntimeLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::ResetRuntimeLogConfiguration, request);
        }
 
        template<typename ResetRuntimeLogConfigurationRequestT = Model::ResetRuntimeLogConfigurationRequest>
        void ResetRuntimeLogConfigurationAsync(const ResetRuntimeLogConfigurationRequestT& request, const ResetRuntimeLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::ResetRuntimeLogConfiguration, request, handler, context);
        }
 
        virtual Model::SendConnectorEventOutcome SendConnectorEvent(const Model::SendConnectorEventRequest& request) const;
 
        template<typename SendConnectorEventRequestT = Model::SendConnectorEventRequest>
        Model::SendConnectorEventOutcomeCallable SendConnectorEventCallable(const SendConnectorEventRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::SendConnectorEvent, request);
        }
 
        template<typename SendConnectorEventRequestT = Model::SendConnectorEventRequest>
        void SendConnectorEventAsync(const SendConnectorEventRequestT& request, const SendConnectorEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::SendConnectorEvent, request, handler, context);
        }
 
        virtual Model::SendManagedThingCommandOutcome SendManagedThingCommand(const Model::SendManagedThingCommandRequest& request) const;
 
        template<typename SendManagedThingCommandRequestT = Model::SendManagedThingCommandRequest>
        Model::SendManagedThingCommandOutcomeCallable SendManagedThingCommandCallable(const SendManagedThingCommandRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::SendManagedThingCommand, request);
        }
 
        template<typename SendManagedThingCommandRequestT = Model::SendManagedThingCommandRequest>
        void SendManagedThingCommandAsync(const SendManagedThingCommandRequestT& request, const SendManagedThingCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::SendManagedThingCommand, request, handler, context);
        }
 
        virtual Model::StartAccountAssociationRefreshOutcome StartAccountAssociationRefresh(const Model::StartAccountAssociationRefreshRequest& request) const;
 
        template<typename StartAccountAssociationRefreshRequestT = Model::StartAccountAssociationRefreshRequest>
        Model::StartAccountAssociationRefreshOutcomeCallable StartAccountAssociationRefreshCallable(const StartAccountAssociationRefreshRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::StartAccountAssociationRefresh, request);
        }
 
        template<typename StartAccountAssociationRefreshRequestT = Model::StartAccountAssociationRefreshRequest>
        void StartAccountAssociationRefreshAsync(const StartAccountAssociationRefreshRequestT& request, const StartAccountAssociationRefreshResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::StartAccountAssociationRefresh, request, handler, context);
        }
 
        virtual Model::StartDeviceDiscoveryOutcome StartDeviceDiscovery(const Model::StartDeviceDiscoveryRequest& request) const;
 
        template<typename StartDeviceDiscoveryRequestT = Model::StartDeviceDiscoveryRequest>
        Model::StartDeviceDiscoveryOutcomeCallable StartDeviceDiscoveryCallable(const StartDeviceDiscoveryRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::StartDeviceDiscovery, request);
        }
 
        template<typename StartDeviceDiscoveryRequestT = Model::StartDeviceDiscoveryRequest>
        void StartDeviceDiscoveryAsync(const StartDeviceDiscoveryRequestT& request, const StartDeviceDiscoveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::StartDeviceDiscovery, 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(&IoTManagedIntegrationsClient::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(&IoTManagedIntegrationsClient::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(&IoTManagedIntegrationsClient::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(&IoTManagedIntegrationsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccountAssociationOutcome UpdateAccountAssociation(const Model::UpdateAccountAssociationRequest& request) const;
 
        template<typename UpdateAccountAssociationRequestT = Model::UpdateAccountAssociationRequest>
        Model::UpdateAccountAssociationOutcomeCallable UpdateAccountAssociationCallable(const UpdateAccountAssociationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateAccountAssociation, request);
        }
 
        template<typename UpdateAccountAssociationRequestT = Model::UpdateAccountAssociationRequest>
        void UpdateAccountAssociationAsync(const UpdateAccountAssociationRequestT& request, const UpdateAccountAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateAccountAssociation, request, handler, context);
        }
 
        virtual Model::UpdateCloudConnectorOutcome UpdateCloudConnector(const Model::UpdateCloudConnectorRequest& request) const;
 
        template<typename UpdateCloudConnectorRequestT = Model::UpdateCloudConnectorRequest>
        Model::UpdateCloudConnectorOutcomeCallable UpdateCloudConnectorCallable(const UpdateCloudConnectorRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateCloudConnector, request);
        }
 
        template<typename UpdateCloudConnectorRequestT = Model::UpdateCloudConnectorRequest>
        void UpdateCloudConnectorAsync(const UpdateCloudConnectorRequestT& request, const UpdateCloudConnectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateCloudConnector, request, handler, context);
        }
 
        virtual Model::UpdateConnectorDestinationOutcome UpdateConnectorDestination(const Model::UpdateConnectorDestinationRequest& request) const;
 
        template<typename UpdateConnectorDestinationRequestT = Model::UpdateConnectorDestinationRequest>
        Model::UpdateConnectorDestinationOutcomeCallable UpdateConnectorDestinationCallable(const UpdateConnectorDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateConnectorDestination, request);
        }
 
        template<typename UpdateConnectorDestinationRequestT = Model::UpdateConnectorDestinationRequest>
        void UpdateConnectorDestinationAsync(const UpdateConnectorDestinationRequestT& request, const UpdateConnectorDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateConnectorDestination, request, handler, context);
        }
 
        virtual Model::UpdateDestinationOutcome UpdateDestination(const Model::UpdateDestinationRequest& request) const;
 
        template<typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
        Model::UpdateDestinationOutcomeCallable UpdateDestinationCallable(const UpdateDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateDestination, request);
        }
 
        template<typename UpdateDestinationRequestT = Model::UpdateDestinationRequest>
        void UpdateDestinationAsync(const UpdateDestinationRequestT& request, const UpdateDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateDestination, request, handler, context);
        }
 
        virtual Model::UpdateEventLogConfigurationOutcome UpdateEventLogConfiguration(const Model::UpdateEventLogConfigurationRequest& request) const;
 
        template<typename UpdateEventLogConfigurationRequestT = Model::UpdateEventLogConfigurationRequest>
        Model::UpdateEventLogConfigurationOutcomeCallable UpdateEventLogConfigurationCallable(const UpdateEventLogConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateEventLogConfiguration, request);
        }
 
        template<typename UpdateEventLogConfigurationRequestT = Model::UpdateEventLogConfigurationRequest>
        void UpdateEventLogConfigurationAsync(const UpdateEventLogConfigurationRequestT& request, const UpdateEventLogConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateEventLogConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateManagedThingOutcome UpdateManagedThing(const Model::UpdateManagedThingRequest& request) const;
 
        template<typename UpdateManagedThingRequestT = Model::UpdateManagedThingRequest>
        Model::UpdateManagedThingOutcomeCallable UpdateManagedThingCallable(const UpdateManagedThingRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateManagedThing, request);
        }
 
        template<typename UpdateManagedThingRequestT = Model::UpdateManagedThingRequest>
        void UpdateManagedThingAsync(const UpdateManagedThingRequestT& request, const UpdateManagedThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateManagedThing, request, handler, context);
        }
 
        virtual Model::UpdateNotificationConfigurationOutcome UpdateNotificationConfiguration(const Model::UpdateNotificationConfigurationRequest& request) const;
 
        template<typename UpdateNotificationConfigurationRequestT = Model::UpdateNotificationConfigurationRequest>
        Model::UpdateNotificationConfigurationOutcomeCallable UpdateNotificationConfigurationCallable(const UpdateNotificationConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateNotificationConfiguration, request);
        }
 
        template<typename UpdateNotificationConfigurationRequestT = Model::UpdateNotificationConfigurationRequest>
        void UpdateNotificationConfigurationAsync(const UpdateNotificationConfigurationRequestT& request, const UpdateNotificationConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateNotificationConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateOtaTaskOutcome UpdateOtaTask(const Model::UpdateOtaTaskRequest& request) const;
 
        template<typename UpdateOtaTaskRequestT = Model::UpdateOtaTaskRequest>
        Model::UpdateOtaTaskOutcomeCallable UpdateOtaTaskCallable(const UpdateOtaTaskRequestT& request) const
        {
            return SubmitCallable(&IoTManagedIntegrationsClient::UpdateOtaTask, request);
        }
 
        template<typename UpdateOtaTaskRequestT = Model::UpdateOtaTaskRequest>
        void UpdateOtaTaskAsync(const UpdateOtaTaskRequestT& request, const UpdateOtaTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTManagedIntegrationsClient::UpdateOtaTask, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTManagedIntegrationsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTManagedIntegrationsClient>;
      void init(const IoTManagedIntegrationsClientConfiguration& clientConfiguration);
 
      IoTManagedIntegrationsClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTManagedIntegrationsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoTManagedIntegrations
} // namespace Aws