IoTClient.h

 
#pragma once
#include <aws/iot/IoT_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/IoTServiceClientModel.h>
 
namespace Aws
{
namespace IoT
{
  class AWS_IOT_API IoTClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<IoTClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef IoTClientConfiguration ClientConfigurationType;
      typedef IoTEndpointProvider EndpointProviderType;
 
        IoTClient(const Aws::IoT::IoTClientConfiguration& clientConfiguration = Aws::IoT::IoTClientConfiguration(),
                  std::shared_ptr<IoTEndpointProviderBase> endpointProvider = nullptr);
 
        IoTClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<IoTEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::IoT::IoTClientConfiguration& clientConfiguration = Aws::IoT::IoTClientConfiguration());
 
        IoTClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<IoTEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::IoT::IoTClientConfiguration& clientConfiguration = Aws::IoT::IoTClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        IoTClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        IoTClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~IoTClient();
 
        virtual Model::AcceptCertificateTransferOutcome AcceptCertificateTransfer(const Model::AcceptCertificateTransferRequest& request) const;
 
        template<typename AcceptCertificateTransferRequestT = Model::AcceptCertificateTransferRequest>
        Model::AcceptCertificateTransferOutcomeCallable AcceptCertificateTransferCallable(const AcceptCertificateTransferRequestT& request) const
        {
            return SubmitCallable(&IoTClient::AcceptCertificateTransfer, request);
        }
 
        template<typename AcceptCertificateTransferRequestT = Model::AcceptCertificateTransferRequest>
        void AcceptCertificateTransferAsync(const AcceptCertificateTransferRequestT& request, const AcceptCertificateTransferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::AcceptCertificateTransfer, request, handler, context);
        }
 
        virtual Model::AddThingToBillingGroupOutcome AddThingToBillingGroup(const Model::AddThingToBillingGroupRequest& request = {}) const;
 
        template<typename AddThingToBillingGroupRequestT = Model::AddThingToBillingGroupRequest>
        Model::AddThingToBillingGroupOutcomeCallable AddThingToBillingGroupCallable(const AddThingToBillingGroupRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::AddThingToBillingGroup, request);
        }
 
        template<typename AddThingToBillingGroupRequestT = Model::AddThingToBillingGroupRequest>
        void AddThingToBillingGroupAsync(const AddThingToBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const AddThingToBillingGroupRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::AddThingToBillingGroup, request, handler, context);
        }
 
        virtual Model::AddThingToThingGroupOutcome AddThingToThingGroup(const Model::AddThingToThingGroupRequest& request = {}) const;
 
        template<typename AddThingToThingGroupRequestT = Model::AddThingToThingGroupRequest>
        Model::AddThingToThingGroupOutcomeCallable AddThingToThingGroupCallable(const AddThingToThingGroupRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::AddThingToThingGroup, request);
        }
 
        template<typename AddThingToThingGroupRequestT = Model::AddThingToThingGroupRequest>
        void AddThingToThingGroupAsync(const AddThingToThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const AddThingToThingGroupRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::AddThingToThingGroup, request, handler, context);
        }
 
        virtual Model::AssociateSbomWithPackageVersionOutcome AssociateSbomWithPackageVersion(const Model::AssociateSbomWithPackageVersionRequest& request) const;
 
        template<typename AssociateSbomWithPackageVersionRequestT = Model::AssociateSbomWithPackageVersionRequest>
        Model::AssociateSbomWithPackageVersionOutcomeCallable AssociateSbomWithPackageVersionCallable(const AssociateSbomWithPackageVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::AssociateSbomWithPackageVersion, request);
        }
 
        template<typename AssociateSbomWithPackageVersionRequestT = Model::AssociateSbomWithPackageVersionRequest>
        void AssociateSbomWithPackageVersionAsync(const AssociateSbomWithPackageVersionRequestT& request, const AssociateSbomWithPackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::AssociateSbomWithPackageVersion, request, handler, context);
        }
 
        virtual Model::AssociateTargetsWithJobOutcome AssociateTargetsWithJob(const Model::AssociateTargetsWithJobRequest& request) const;
 
        template<typename AssociateTargetsWithJobRequestT = Model::AssociateTargetsWithJobRequest>
        Model::AssociateTargetsWithJobOutcomeCallable AssociateTargetsWithJobCallable(const AssociateTargetsWithJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::AssociateTargetsWithJob, request);
        }
 
        template<typename AssociateTargetsWithJobRequestT = Model::AssociateTargetsWithJobRequest>
        void AssociateTargetsWithJobAsync(const AssociateTargetsWithJobRequestT& request, const AssociateTargetsWithJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::AssociateTargetsWithJob, request, handler, context);
        }
 
        virtual Model::AttachPolicyOutcome AttachPolicy(const Model::AttachPolicyRequest& request) const;
 
        template<typename AttachPolicyRequestT = Model::AttachPolicyRequest>
        Model::AttachPolicyOutcomeCallable AttachPolicyCallable(const AttachPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTClient::AttachPolicy, request);
        }
 
        template<typename AttachPolicyRequestT = Model::AttachPolicyRequest>
        void AttachPolicyAsync(const AttachPolicyRequestT& request, const AttachPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::AttachPolicy, request, handler, context);
        }
 
        virtual Model::AttachSecurityProfileOutcome AttachSecurityProfile(const Model::AttachSecurityProfileRequest& request) const;
 
        template<typename AttachSecurityProfileRequestT = Model::AttachSecurityProfileRequest>
        Model::AttachSecurityProfileOutcomeCallable AttachSecurityProfileCallable(const AttachSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::AttachSecurityProfile, request);
        }
 
        template<typename AttachSecurityProfileRequestT = Model::AttachSecurityProfileRequest>
        void AttachSecurityProfileAsync(const AttachSecurityProfileRequestT& request, const AttachSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::AttachSecurityProfile, request, handler, context);
        }
 
        virtual Model::AttachThingPrincipalOutcome AttachThingPrincipal(const Model::AttachThingPrincipalRequest& request) const;
 
        template<typename AttachThingPrincipalRequestT = Model::AttachThingPrincipalRequest>
        Model::AttachThingPrincipalOutcomeCallable AttachThingPrincipalCallable(const AttachThingPrincipalRequestT& request) const
        {
            return SubmitCallable(&IoTClient::AttachThingPrincipal, request);
        }
 
        template<typename AttachThingPrincipalRequestT = Model::AttachThingPrincipalRequest>
        void AttachThingPrincipalAsync(const AttachThingPrincipalRequestT& request, const AttachThingPrincipalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::AttachThingPrincipal, request, handler, context);
        }
 
        virtual Model::CancelAuditMitigationActionsTaskOutcome CancelAuditMitigationActionsTask(const Model::CancelAuditMitigationActionsTaskRequest& request) const;
 
        template<typename CancelAuditMitigationActionsTaskRequestT = Model::CancelAuditMitigationActionsTaskRequest>
        Model::CancelAuditMitigationActionsTaskOutcomeCallable CancelAuditMitigationActionsTaskCallable(const CancelAuditMitigationActionsTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CancelAuditMitigationActionsTask, request);
        }
 
        template<typename CancelAuditMitigationActionsTaskRequestT = Model::CancelAuditMitigationActionsTaskRequest>
        void CancelAuditMitigationActionsTaskAsync(const CancelAuditMitigationActionsTaskRequestT& request, const CancelAuditMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CancelAuditMitigationActionsTask, request, handler, context);
        }
 
        virtual Model::CancelAuditTaskOutcome CancelAuditTask(const Model::CancelAuditTaskRequest& request) const;
 
        template<typename CancelAuditTaskRequestT = Model::CancelAuditTaskRequest>
        Model::CancelAuditTaskOutcomeCallable CancelAuditTaskCallable(const CancelAuditTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CancelAuditTask, request);
        }
 
        template<typename CancelAuditTaskRequestT = Model::CancelAuditTaskRequest>
        void CancelAuditTaskAsync(const CancelAuditTaskRequestT& request, const CancelAuditTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CancelAuditTask, request, handler, context);
        }
 
        virtual Model::CancelCertificateTransferOutcome CancelCertificateTransfer(const Model::CancelCertificateTransferRequest& request) const;
 
        template<typename CancelCertificateTransferRequestT = Model::CancelCertificateTransferRequest>
        Model::CancelCertificateTransferOutcomeCallable CancelCertificateTransferCallable(const CancelCertificateTransferRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CancelCertificateTransfer, request);
        }
 
        template<typename CancelCertificateTransferRequestT = Model::CancelCertificateTransferRequest>
        void CancelCertificateTransferAsync(const CancelCertificateTransferRequestT& request, const CancelCertificateTransferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CancelCertificateTransfer, request, handler, context);
        }
 
        virtual Model::CancelDetectMitigationActionsTaskOutcome CancelDetectMitigationActionsTask(const Model::CancelDetectMitigationActionsTaskRequest& request) const;
 
        template<typename CancelDetectMitigationActionsTaskRequestT = Model::CancelDetectMitigationActionsTaskRequest>
        Model::CancelDetectMitigationActionsTaskOutcomeCallable CancelDetectMitigationActionsTaskCallable(const CancelDetectMitigationActionsTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CancelDetectMitigationActionsTask, request);
        }
 
        template<typename CancelDetectMitigationActionsTaskRequestT = Model::CancelDetectMitigationActionsTaskRequest>
        void CancelDetectMitigationActionsTaskAsync(const CancelDetectMitigationActionsTaskRequestT& request, const CancelDetectMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CancelDetectMitigationActionsTask, request, handler, context);
        }
 
        virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CancelJob, request);
        }
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CancelJob, request, handler, context);
        }
 
        virtual Model::CancelJobExecutionOutcome CancelJobExecution(const Model::CancelJobExecutionRequest& request) const;
 
        template<typename CancelJobExecutionRequestT = Model::CancelJobExecutionRequest>
        Model::CancelJobExecutionOutcomeCallable CancelJobExecutionCallable(const CancelJobExecutionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CancelJobExecution, request);
        }
 
        template<typename CancelJobExecutionRequestT = Model::CancelJobExecutionRequest>
        void CancelJobExecutionAsync(const CancelJobExecutionRequestT& request, const CancelJobExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CancelJobExecution, request, handler, context);
        }
 
        virtual Model::ClearDefaultAuthorizerOutcome ClearDefaultAuthorizer(const Model::ClearDefaultAuthorizerRequest& request = {}) const;
 
        template<typename ClearDefaultAuthorizerRequestT = Model::ClearDefaultAuthorizerRequest>
        Model::ClearDefaultAuthorizerOutcomeCallable ClearDefaultAuthorizerCallable(const ClearDefaultAuthorizerRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ClearDefaultAuthorizer, request);
        }
 
        template<typename ClearDefaultAuthorizerRequestT = Model::ClearDefaultAuthorizerRequest>
        void ClearDefaultAuthorizerAsync(const ClearDefaultAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ClearDefaultAuthorizerRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ClearDefaultAuthorizer, request, handler, context);
        }
 
        virtual Model::ConfirmTopicRuleDestinationOutcome ConfirmTopicRuleDestination(const Model::ConfirmTopicRuleDestinationRequest& request) const;
 
        template<typename ConfirmTopicRuleDestinationRequestT = Model::ConfirmTopicRuleDestinationRequest>
        Model::ConfirmTopicRuleDestinationOutcomeCallable ConfirmTopicRuleDestinationCallable(const ConfirmTopicRuleDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ConfirmTopicRuleDestination, request);
        }
 
        template<typename ConfirmTopicRuleDestinationRequestT = Model::ConfirmTopicRuleDestinationRequest>
        void ConfirmTopicRuleDestinationAsync(const ConfirmTopicRuleDestinationRequestT& request, const ConfirmTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ConfirmTopicRuleDestination, request, handler, context);
        }
 
        virtual Model::CreateAuditSuppressionOutcome CreateAuditSuppression(const Model::CreateAuditSuppressionRequest& request) const;
 
        template<typename CreateAuditSuppressionRequestT = Model::CreateAuditSuppressionRequest>
        Model::CreateAuditSuppressionOutcomeCallable CreateAuditSuppressionCallable(const CreateAuditSuppressionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateAuditSuppression, request);
        }
 
        template<typename CreateAuditSuppressionRequestT = Model::CreateAuditSuppressionRequest>
        void CreateAuditSuppressionAsync(const CreateAuditSuppressionRequestT& request, const CreateAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateAuditSuppression, request, handler, context);
        }
 
        virtual Model::CreateAuthorizerOutcome CreateAuthorizer(const Model::CreateAuthorizerRequest& request) const;
 
        template<typename CreateAuthorizerRequestT = Model::CreateAuthorizerRequest>
        Model::CreateAuthorizerOutcomeCallable CreateAuthorizerCallable(const CreateAuthorizerRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateAuthorizer, request);
        }
 
        template<typename CreateAuthorizerRequestT = Model::CreateAuthorizerRequest>
        void CreateAuthorizerAsync(const CreateAuthorizerRequestT& request, const CreateAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateAuthorizer, request, handler, context);
        }
 
        virtual Model::CreateBillingGroupOutcome CreateBillingGroup(const Model::CreateBillingGroupRequest& request) const;
 
        template<typename CreateBillingGroupRequestT = Model::CreateBillingGroupRequest>
        Model::CreateBillingGroupOutcomeCallable CreateBillingGroupCallable(const CreateBillingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateBillingGroup, request);
        }
 
        template<typename CreateBillingGroupRequestT = Model::CreateBillingGroupRequest>
        void CreateBillingGroupAsync(const CreateBillingGroupRequestT& request, const CreateBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateBillingGroup, request, handler, context);
        }
 
        virtual Model::CreateCertificateFromCsrOutcome CreateCertificateFromCsr(const Model::CreateCertificateFromCsrRequest& request) const;
 
        template<typename CreateCertificateFromCsrRequestT = Model::CreateCertificateFromCsrRequest>
        Model::CreateCertificateFromCsrOutcomeCallable CreateCertificateFromCsrCallable(const CreateCertificateFromCsrRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateCertificateFromCsr, request);
        }
 
        template<typename CreateCertificateFromCsrRequestT = Model::CreateCertificateFromCsrRequest>
        void CreateCertificateFromCsrAsync(const CreateCertificateFromCsrRequestT& request, const CreateCertificateFromCsrResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateCertificateFromCsr, request, handler, context);
        }
 
        virtual Model::CreateCertificateProviderOutcome CreateCertificateProvider(const Model::CreateCertificateProviderRequest& request) const;
 
        template<typename CreateCertificateProviderRequestT = Model::CreateCertificateProviderRequest>
        Model::CreateCertificateProviderOutcomeCallable CreateCertificateProviderCallable(const CreateCertificateProviderRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateCertificateProvider, request);
        }
 
        template<typename CreateCertificateProviderRequestT = Model::CreateCertificateProviderRequest>
        void CreateCertificateProviderAsync(const CreateCertificateProviderRequestT& request, const CreateCertificateProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateCertificateProvider, request, handler, context);
        }
 
        virtual Model::CreateCommandOutcome CreateCommand(const Model::CreateCommandRequest& request) const;
 
        template<typename CreateCommandRequestT = Model::CreateCommandRequest>
        Model::CreateCommandOutcomeCallable CreateCommandCallable(const CreateCommandRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateCommand, request);
        }
 
        template<typename CreateCommandRequestT = Model::CreateCommandRequest>
        void CreateCommandAsync(const CreateCommandRequestT& request, const CreateCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateCommand, request, handler, context);
        }
 
        virtual Model::CreateCustomMetricOutcome CreateCustomMetric(const Model::CreateCustomMetricRequest& request) const;
 
        template<typename CreateCustomMetricRequestT = Model::CreateCustomMetricRequest>
        Model::CreateCustomMetricOutcomeCallable CreateCustomMetricCallable(const CreateCustomMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateCustomMetric, request);
        }
 
        template<typename CreateCustomMetricRequestT = Model::CreateCustomMetricRequest>
        void CreateCustomMetricAsync(const CreateCustomMetricRequestT& request, const CreateCustomMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateCustomMetric, request, handler, context);
        }
 
        virtual Model::CreateDimensionOutcome CreateDimension(const Model::CreateDimensionRequest& request) const;
 
        template<typename CreateDimensionRequestT = Model::CreateDimensionRequest>
        Model::CreateDimensionOutcomeCallable CreateDimensionCallable(const CreateDimensionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateDimension, request);
        }
 
        template<typename CreateDimensionRequestT = Model::CreateDimensionRequest>
        void CreateDimensionAsync(const CreateDimensionRequestT& request, const CreateDimensionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateDimension, request, handler, context);
        }
 
        virtual Model::CreateDomainConfigurationOutcome CreateDomainConfiguration(const Model::CreateDomainConfigurationRequest& request) const;
 
        template<typename CreateDomainConfigurationRequestT = Model::CreateDomainConfigurationRequest>
        Model::CreateDomainConfigurationOutcomeCallable CreateDomainConfigurationCallable(const CreateDomainConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateDomainConfiguration, request);
        }
 
        template<typename CreateDomainConfigurationRequestT = Model::CreateDomainConfigurationRequest>
        void CreateDomainConfigurationAsync(const CreateDomainConfigurationRequestT& request, const CreateDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateDomainConfiguration, request, handler, context);
        }
 
        virtual Model::CreateDynamicThingGroupOutcome CreateDynamicThingGroup(const Model::CreateDynamicThingGroupRequest& request) const;
 
        template<typename CreateDynamicThingGroupRequestT = Model::CreateDynamicThingGroupRequest>
        Model::CreateDynamicThingGroupOutcomeCallable CreateDynamicThingGroupCallable(const CreateDynamicThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateDynamicThingGroup, request);
        }
 
        template<typename CreateDynamicThingGroupRequestT = Model::CreateDynamicThingGroupRequest>
        void CreateDynamicThingGroupAsync(const CreateDynamicThingGroupRequestT& request, const CreateDynamicThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateDynamicThingGroup, request, handler, context);
        }
 
        virtual Model::CreateFleetMetricOutcome CreateFleetMetric(const Model::CreateFleetMetricRequest& request) const;
 
        template<typename CreateFleetMetricRequestT = Model::CreateFleetMetricRequest>
        Model::CreateFleetMetricOutcomeCallable CreateFleetMetricCallable(const CreateFleetMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateFleetMetric, request);
        }
 
        template<typename CreateFleetMetricRequestT = Model::CreateFleetMetricRequest>
        void CreateFleetMetricAsync(const CreateFleetMetricRequestT& request, const CreateFleetMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateFleetMetric, request, handler, context);
        }
 
        virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const;
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateJob, request);
        }
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateJob, request, handler, context);
        }
 
        virtual Model::CreateJobTemplateOutcome CreateJobTemplate(const Model::CreateJobTemplateRequest& request) const;
 
        template<typename CreateJobTemplateRequestT = Model::CreateJobTemplateRequest>
        Model::CreateJobTemplateOutcomeCallable CreateJobTemplateCallable(const CreateJobTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateJobTemplate, request);
        }
 
        template<typename CreateJobTemplateRequestT = Model::CreateJobTemplateRequest>
        void CreateJobTemplateAsync(const CreateJobTemplateRequestT& request, const CreateJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateJobTemplate, request, handler, context);
        }
 
        virtual Model::CreateKeysAndCertificateOutcome CreateKeysAndCertificate(const Model::CreateKeysAndCertificateRequest& request = {}) const;
 
        template<typename CreateKeysAndCertificateRequestT = Model::CreateKeysAndCertificateRequest>
        Model::CreateKeysAndCertificateOutcomeCallable CreateKeysAndCertificateCallable(const CreateKeysAndCertificateRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::CreateKeysAndCertificate, request);
        }
 
        template<typename CreateKeysAndCertificateRequestT = Model::CreateKeysAndCertificateRequest>
        void CreateKeysAndCertificateAsync(const CreateKeysAndCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateKeysAndCertificateRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::CreateKeysAndCertificate, request, handler, context);
        }
 
        virtual Model::CreateMitigationActionOutcome CreateMitigationAction(const Model::CreateMitigationActionRequest& request) const;
 
        template<typename CreateMitigationActionRequestT = Model::CreateMitigationActionRequest>
        Model::CreateMitigationActionOutcomeCallable CreateMitigationActionCallable(const CreateMitigationActionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateMitigationAction, request);
        }
 
        template<typename CreateMitigationActionRequestT = Model::CreateMitigationActionRequest>
        void CreateMitigationActionAsync(const CreateMitigationActionRequestT& request, const CreateMitigationActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateMitigationAction, request, handler, context);
        }
 
        virtual Model::CreateOTAUpdateOutcome CreateOTAUpdate(const Model::CreateOTAUpdateRequest& request) const;
 
        template<typename CreateOTAUpdateRequestT = Model::CreateOTAUpdateRequest>
        Model::CreateOTAUpdateOutcomeCallable CreateOTAUpdateCallable(const CreateOTAUpdateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateOTAUpdate, request);
        }
 
        template<typename CreateOTAUpdateRequestT = Model::CreateOTAUpdateRequest>
        void CreateOTAUpdateAsync(const CreateOTAUpdateRequestT& request, const CreateOTAUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateOTAUpdate, request, handler, context);
        }
 
        virtual Model::CreatePackageOutcome CreatePackage(const Model::CreatePackageRequest& request) const;
 
        template<typename CreatePackageRequestT = Model::CreatePackageRequest>
        Model::CreatePackageOutcomeCallable CreatePackageCallable(const CreatePackageRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreatePackage, request);
        }
 
        template<typename CreatePackageRequestT = Model::CreatePackageRequest>
        void CreatePackageAsync(const CreatePackageRequestT& request, const CreatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreatePackage, request, handler, context);
        }
 
        virtual Model::CreatePackageVersionOutcome CreatePackageVersion(const Model::CreatePackageVersionRequest& request) const;
 
        template<typename CreatePackageVersionRequestT = Model::CreatePackageVersionRequest>
        Model::CreatePackageVersionOutcomeCallable CreatePackageVersionCallable(const CreatePackageVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreatePackageVersion, request);
        }
 
        template<typename CreatePackageVersionRequestT = Model::CreatePackageVersionRequest>
        void CreatePackageVersionAsync(const CreatePackageVersionRequestT& request, const CreatePackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreatePackageVersion, request, handler, context);
        }
 
        virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const;
 
        template<typename CreatePolicyRequestT = Model::CreatePolicyRequest>
        Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreatePolicy, request);
        }
 
        template<typename CreatePolicyRequestT = Model::CreatePolicyRequest>
        void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreatePolicy, request, handler, context);
        }
 
        virtual Model::CreatePolicyVersionOutcome CreatePolicyVersion(const Model::CreatePolicyVersionRequest& request) const;
 
        template<typename CreatePolicyVersionRequestT = Model::CreatePolicyVersionRequest>
        Model::CreatePolicyVersionOutcomeCallable CreatePolicyVersionCallable(const CreatePolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreatePolicyVersion, request);
        }
 
        template<typename CreatePolicyVersionRequestT = Model::CreatePolicyVersionRequest>
        void CreatePolicyVersionAsync(const CreatePolicyVersionRequestT& request, const CreatePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreatePolicyVersion, request, handler, context);
        }
 
        virtual Model::CreateProvisioningClaimOutcome CreateProvisioningClaim(const Model::CreateProvisioningClaimRequest& request) const;
 
        template<typename CreateProvisioningClaimRequestT = Model::CreateProvisioningClaimRequest>
        Model::CreateProvisioningClaimOutcomeCallable CreateProvisioningClaimCallable(const CreateProvisioningClaimRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateProvisioningClaim, request);
        }
 
        template<typename CreateProvisioningClaimRequestT = Model::CreateProvisioningClaimRequest>
        void CreateProvisioningClaimAsync(const CreateProvisioningClaimRequestT& request, const CreateProvisioningClaimResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateProvisioningClaim, request, handler, context);
        }
 
        virtual Model::CreateProvisioningTemplateOutcome CreateProvisioningTemplate(const Model::CreateProvisioningTemplateRequest& request) const;
 
        template<typename CreateProvisioningTemplateRequestT = Model::CreateProvisioningTemplateRequest>
        Model::CreateProvisioningTemplateOutcomeCallable CreateProvisioningTemplateCallable(const CreateProvisioningTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateProvisioningTemplate, request);
        }
 
        template<typename CreateProvisioningTemplateRequestT = Model::CreateProvisioningTemplateRequest>
        void CreateProvisioningTemplateAsync(const CreateProvisioningTemplateRequestT& request, const CreateProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateProvisioningTemplate, request, handler, context);
        }
 
        virtual Model::CreateProvisioningTemplateVersionOutcome CreateProvisioningTemplateVersion(const Model::CreateProvisioningTemplateVersionRequest& request) const;
 
        template<typename CreateProvisioningTemplateVersionRequestT = Model::CreateProvisioningTemplateVersionRequest>
        Model::CreateProvisioningTemplateVersionOutcomeCallable CreateProvisioningTemplateVersionCallable(const CreateProvisioningTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateProvisioningTemplateVersion, request);
        }
 
        template<typename CreateProvisioningTemplateVersionRequestT = Model::CreateProvisioningTemplateVersionRequest>
        void CreateProvisioningTemplateVersionAsync(const CreateProvisioningTemplateVersionRequestT& request, const CreateProvisioningTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateProvisioningTemplateVersion, request, handler, context);
        }
 
        virtual Model::CreateRoleAliasOutcome CreateRoleAlias(const Model::CreateRoleAliasRequest& request) const;
 
        template<typename CreateRoleAliasRequestT = Model::CreateRoleAliasRequest>
        Model::CreateRoleAliasOutcomeCallable CreateRoleAliasCallable(const CreateRoleAliasRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateRoleAlias, request);
        }
 
        template<typename CreateRoleAliasRequestT = Model::CreateRoleAliasRequest>
        void CreateRoleAliasAsync(const CreateRoleAliasRequestT& request, const CreateRoleAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateRoleAlias, request, handler, context);
        }
 
        virtual Model::CreateScheduledAuditOutcome CreateScheduledAudit(const Model::CreateScheduledAuditRequest& request) const;
 
        template<typename CreateScheduledAuditRequestT = Model::CreateScheduledAuditRequest>
        Model::CreateScheduledAuditOutcomeCallable CreateScheduledAuditCallable(const CreateScheduledAuditRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateScheduledAudit, request);
        }
 
        template<typename CreateScheduledAuditRequestT = Model::CreateScheduledAuditRequest>
        void CreateScheduledAuditAsync(const CreateScheduledAuditRequestT& request, const CreateScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateScheduledAudit, request, handler, context);
        }
 
        virtual Model::CreateSecurityProfileOutcome CreateSecurityProfile(const Model::CreateSecurityProfileRequest& request) const;
 
        template<typename CreateSecurityProfileRequestT = Model::CreateSecurityProfileRequest>
        Model::CreateSecurityProfileOutcomeCallable CreateSecurityProfileCallable(const CreateSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateSecurityProfile, request);
        }
 
        template<typename CreateSecurityProfileRequestT = Model::CreateSecurityProfileRequest>
        void CreateSecurityProfileAsync(const CreateSecurityProfileRequestT& request, const CreateSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateSecurityProfile, request, handler, context);
        }
 
        virtual Model::CreateStreamOutcome CreateStream(const Model::CreateStreamRequest& request) const;
 
        template<typename CreateStreamRequestT = Model::CreateStreamRequest>
        Model::CreateStreamOutcomeCallable CreateStreamCallable(const CreateStreamRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateStream, request);
        }
 
        template<typename CreateStreamRequestT = Model::CreateStreamRequest>
        void CreateStreamAsync(const CreateStreamRequestT& request, const CreateStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateStream, request, handler, context);
        }
 
        virtual Model::CreateThingOutcome CreateThing(const Model::CreateThingRequest& request) const;
 
        template<typename CreateThingRequestT = Model::CreateThingRequest>
        Model::CreateThingOutcomeCallable CreateThingCallable(const CreateThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateThing, request);
        }
 
        template<typename CreateThingRequestT = Model::CreateThingRequest>
        void CreateThingAsync(const CreateThingRequestT& request, const CreateThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateThing, request, handler, context);
        }
 
        virtual Model::CreateThingGroupOutcome CreateThingGroup(const Model::CreateThingGroupRequest& request) const;
 
        template<typename CreateThingGroupRequestT = Model::CreateThingGroupRequest>
        Model::CreateThingGroupOutcomeCallable CreateThingGroupCallable(const CreateThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateThingGroup, request);
        }
 
        template<typename CreateThingGroupRequestT = Model::CreateThingGroupRequest>
        void CreateThingGroupAsync(const CreateThingGroupRequestT& request, const CreateThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateThingGroup, request, handler, context);
        }
 
        virtual Model::CreateThingTypeOutcome CreateThingType(const Model::CreateThingTypeRequest& request) const;
 
        template<typename CreateThingTypeRequestT = Model::CreateThingTypeRequest>
        Model::CreateThingTypeOutcomeCallable CreateThingTypeCallable(const CreateThingTypeRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateThingType, request);
        }
 
        template<typename CreateThingTypeRequestT = Model::CreateThingTypeRequest>
        void CreateThingTypeAsync(const CreateThingTypeRequestT& request, const CreateThingTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateThingType, request, handler, context);
        }
 
        virtual Model::CreateTopicRuleOutcome CreateTopicRule(const Model::CreateTopicRuleRequest& request) const;
 
        template<typename CreateTopicRuleRequestT = Model::CreateTopicRuleRequest>
        Model::CreateTopicRuleOutcomeCallable CreateTopicRuleCallable(const CreateTopicRuleRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateTopicRule, request);
        }
 
        template<typename CreateTopicRuleRequestT = Model::CreateTopicRuleRequest>
        void CreateTopicRuleAsync(const CreateTopicRuleRequestT& request, const CreateTopicRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateTopicRule, request, handler, context);
        }
 
        virtual Model::CreateTopicRuleDestinationOutcome CreateTopicRuleDestination(const Model::CreateTopicRuleDestinationRequest& request) const;
 
        template<typename CreateTopicRuleDestinationRequestT = Model::CreateTopicRuleDestinationRequest>
        Model::CreateTopicRuleDestinationOutcomeCallable CreateTopicRuleDestinationCallable(const CreateTopicRuleDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::CreateTopicRuleDestination, request);
        }
 
        template<typename CreateTopicRuleDestinationRequestT = Model::CreateTopicRuleDestinationRequest>
        void CreateTopicRuleDestinationAsync(const CreateTopicRuleDestinationRequestT& request, const CreateTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::CreateTopicRuleDestination, request, handler, context);
        }
 
        virtual Model::DeleteAccountAuditConfigurationOutcome DeleteAccountAuditConfiguration(const Model::DeleteAccountAuditConfigurationRequest& request = {}) const;
 
        template<typename DeleteAccountAuditConfigurationRequestT = Model::DeleteAccountAuditConfigurationRequest>
        Model::DeleteAccountAuditConfigurationOutcomeCallable DeleteAccountAuditConfigurationCallable(const DeleteAccountAuditConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DeleteAccountAuditConfiguration, request);
        }
 
        template<typename DeleteAccountAuditConfigurationRequestT = Model::DeleteAccountAuditConfigurationRequest>
        void DeleteAccountAuditConfigurationAsync(const DeleteAccountAuditConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteAccountAuditConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DeleteAccountAuditConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteAuditSuppressionOutcome DeleteAuditSuppression(const Model::DeleteAuditSuppressionRequest& request) const;
 
        template<typename DeleteAuditSuppressionRequestT = Model::DeleteAuditSuppressionRequest>
        Model::DeleteAuditSuppressionOutcomeCallable DeleteAuditSuppressionCallable(const DeleteAuditSuppressionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteAuditSuppression, request);
        }
 
        template<typename DeleteAuditSuppressionRequestT = Model::DeleteAuditSuppressionRequest>
        void DeleteAuditSuppressionAsync(const DeleteAuditSuppressionRequestT& request, const DeleteAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteAuditSuppression, request, handler, context);
        }
 
        virtual Model::DeleteAuthorizerOutcome DeleteAuthorizer(const Model::DeleteAuthorizerRequest& request) const;
 
        template<typename DeleteAuthorizerRequestT = Model::DeleteAuthorizerRequest>
        Model::DeleteAuthorizerOutcomeCallable DeleteAuthorizerCallable(const DeleteAuthorizerRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteAuthorizer, request);
        }
 
        template<typename DeleteAuthorizerRequestT = Model::DeleteAuthorizerRequest>
        void DeleteAuthorizerAsync(const DeleteAuthorizerRequestT& request, const DeleteAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteAuthorizer, request, handler, context);
        }
 
        virtual Model::DeleteBillingGroupOutcome DeleteBillingGroup(const Model::DeleteBillingGroupRequest& request) const;
 
        template<typename DeleteBillingGroupRequestT = Model::DeleteBillingGroupRequest>
        Model::DeleteBillingGroupOutcomeCallable DeleteBillingGroupCallable(const DeleteBillingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteBillingGroup, request);
        }
 
        template<typename DeleteBillingGroupRequestT = Model::DeleteBillingGroupRequest>
        void DeleteBillingGroupAsync(const DeleteBillingGroupRequestT& request, const DeleteBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteBillingGroup, request, handler, context);
        }
 
        virtual Model::DeleteCACertificateOutcome DeleteCACertificate(const Model::DeleteCACertificateRequest& request) const;
 
        template<typename DeleteCACertificateRequestT = Model::DeleteCACertificateRequest>
        Model::DeleteCACertificateOutcomeCallable DeleteCACertificateCallable(const DeleteCACertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteCACertificate, request);
        }
 
        template<typename DeleteCACertificateRequestT = Model::DeleteCACertificateRequest>
        void DeleteCACertificateAsync(const DeleteCACertificateRequestT& request, const DeleteCACertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteCACertificate, request, handler, context);
        }
 
        virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest& request) const;
 
        template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
        Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteCertificate, request);
        }
 
        template<typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
        void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteCertificate, request, handler, context);
        }
 
        virtual Model::DeleteCertificateProviderOutcome DeleteCertificateProvider(const Model::DeleteCertificateProviderRequest& request) const;
 
        template<typename DeleteCertificateProviderRequestT = Model::DeleteCertificateProviderRequest>
        Model::DeleteCertificateProviderOutcomeCallable DeleteCertificateProviderCallable(const DeleteCertificateProviderRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteCertificateProvider, request);
        }
 
        template<typename DeleteCertificateProviderRequestT = Model::DeleteCertificateProviderRequest>
        void DeleteCertificateProviderAsync(const DeleteCertificateProviderRequestT& request, const DeleteCertificateProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteCertificateProvider, request, handler, context);
        }
 
        virtual Model::DeleteCommandOutcome DeleteCommand(const Model::DeleteCommandRequest& request) const;
 
        template<typename DeleteCommandRequestT = Model::DeleteCommandRequest>
        Model::DeleteCommandOutcomeCallable DeleteCommandCallable(const DeleteCommandRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteCommand, request);
        }
 
        template<typename DeleteCommandRequestT = Model::DeleteCommandRequest>
        void DeleteCommandAsync(const DeleteCommandRequestT& request, const DeleteCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteCommand, request, handler, context);
        }
 
        virtual Model::DeleteCommandExecutionOutcome DeleteCommandExecution(const Model::DeleteCommandExecutionRequest& request) const;
 
        template<typename DeleteCommandExecutionRequestT = Model::DeleteCommandExecutionRequest>
        Model::DeleteCommandExecutionOutcomeCallable DeleteCommandExecutionCallable(const DeleteCommandExecutionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteCommandExecution, request);
        }
 
        template<typename DeleteCommandExecutionRequestT = Model::DeleteCommandExecutionRequest>
        void DeleteCommandExecutionAsync(const DeleteCommandExecutionRequestT& request, const DeleteCommandExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteCommandExecution, request, handler, context);
        }
 
        virtual Model::DeleteCustomMetricOutcome DeleteCustomMetric(const Model::DeleteCustomMetricRequest& request) const;
 
        template<typename DeleteCustomMetricRequestT = Model::DeleteCustomMetricRequest>
        Model::DeleteCustomMetricOutcomeCallable DeleteCustomMetricCallable(const DeleteCustomMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteCustomMetric, request);
        }
 
        template<typename DeleteCustomMetricRequestT = Model::DeleteCustomMetricRequest>
        void DeleteCustomMetricAsync(const DeleteCustomMetricRequestT& request, const DeleteCustomMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteCustomMetric, request, handler, context);
        }
 
        virtual Model::DeleteDimensionOutcome DeleteDimension(const Model::DeleteDimensionRequest& request) const;
 
        template<typename DeleteDimensionRequestT = Model::DeleteDimensionRequest>
        Model::DeleteDimensionOutcomeCallable DeleteDimensionCallable(const DeleteDimensionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteDimension, request);
        }
 
        template<typename DeleteDimensionRequestT = Model::DeleteDimensionRequest>
        void DeleteDimensionAsync(const DeleteDimensionRequestT& request, const DeleteDimensionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteDimension, request, handler, context);
        }
 
        virtual Model::DeleteDomainConfigurationOutcome DeleteDomainConfiguration(const Model::DeleteDomainConfigurationRequest& request) const;
 
        template<typename DeleteDomainConfigurationRequestT = Model::DeleteDomainConfigurationRequest>
        Model::DeleteDomainConfigurationOutcomeCallable DeleteDomainConfigurationCallable(const DeleteDomainConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteDomainConfiguration, request);
        }
 
        template<typename DeleteDomainConfigurationRequestT = Model::DeleteDomainConfigurationRequest>
        void DeleteDomainConfigurationAsync(const DeleteDomainConfigurationRequestT& request, const DeleteDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteDomainConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteDynamicThingGroupOutcome DeleteDynamicThingGroup(const Model::DeleteDynamicThingGroupRequest& request) const;
 
        template<typename DeleteDynamicThingGroupRequestT = Model::DeleteDynamicThingGroupRequest>
        Model::DeleteDynamicThingGroupOutcomeCallable DeleteDynamicThingGroupCallable(const DeleteDynamicThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteDynamicThingGroup, request);
        }
 
        template<typename DeleteDynamicThingGroupRequestT = Model::DeleteDynamicThingGroupRequest>
        void DeleteDynamicThingGroupAsync(const DeleteDynamicThingGroupRequestT& request, const DeleteDynamicThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteDynamicThingGroup, request, handler, context);
        }
 
        virtual Model::DeleteFleetMetricOutcome DeleteFleetMetric(const Model::DeleteFleetMetricRequest& request) const;
 
        template<typename DeleteFleetMetricRequestT = Model::DeleteFleetMetricRequest>
        Model::DeleteFleetMetricOutcomeCallable DeleteFleetMetricCallable(const DeleteFleetMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteFleetMetric, request);
        }
 
        template<typename DeleteFleetMetricRequestT = Model::DeleteFleetMetricRequest>
        void DeleteFleetMetricAsync(const DeleteFleetMetricRequestT& request, const DeleteFleetMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteFleetMetric, request, handler, context);
        }
 
        virtual Model::DeleteJobOutcome DeleteJob(const Model::DeleteJobRequest& request) const;
 
        template<typename DeleteJobRequestT = Model::DeleteJobRequest>
        Model::DeleteJobOutcomeCallable DeleteJobCallable(const DeleteJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteJob, request);
        }
 
        template<typename DeleteJobRequestT = Model::DeleteJobRequest>
        void DeleteJobAsync(const DeleteJobRequestT& request, const DeleteJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteJob, request, handler, context);
        }
 
        virtual Model::DeleteJobExecutionOutcome DeleteJobExecution(const Model::DeleteJobExecutionRequest& request) const;
 
        template<typename DeleteJobExecutionRequestT = Model::DeleteJobExecutionRequest>
        Model::DeleteJobExecutionOutcomeCallable DeleteJobExecutionCallable(const DeleteJobExecutionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteJobExecution, request);
        }
 
        template<typename DeleteJobExecutionRequestT = Model::DeleteJobExecutionRequest>
        void DeleteJobExecutionAsync(const DeleteJobExecutionRequestT& request, const DeleteJobExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteJobExecution, request, handler, context);
        }
 
        virtual Model::DeleteJobTemplateOutcome DeleteJobTemplate(const Model::DeleteJobTemplateRequest& request) const;
 
        template<typename DeleteJobTemplateRequestT = Model::DeleteJobTemplateRequest>
        Model::DeleteJobTemplateOutcomeCallable DeleteJobTemplateCallable(const DeleteJobTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteJobTemplate, request);
        }
 
        template<typename DeleteJobTemplateRequestT = Model::DeleteJobTemplateRequest>
        void DeleteJobTemplateAsync(const DeleteJobTemplateRequestT& request, const DeleteJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteJobTemplate, request, handler, context);
        }
 
        virtual Model::DeleteMitigationActionOutcome DeleteMitigationAction(const Model::DeleteMitigationActionRequest& request) const;
 
        template<typename DeleteMitigationActionRequestT = Model::DeleteMitigationActionRequest>
        Model::DeleteMitigationActionOutcomeCallable DeleteMitigationActionCallable(const DeleteMitigationActionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteMitigationAction, request);
        }
 
        template<typename DeleteMitigationActionRequestT = Model::DeleteMitigationActionRequest>
        void DeleteMitigationActionAsync(const DeleteMitigationActionRequestT& request, const DeleteMitigationActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteMitigationAction, request, handler, context);
        }
 
        virtual Model::DeleteOTAUpdateOutcome DeleteOTAUpdate(const Model::DeleteOTAUpdateRequest& request) const;
 
        template<typename DeleteOTAUpdateRequestT = Model::DeleteOTAUpdateRequest>
        Model::DeleteOTAUpdateOutcomeCallable DeleteOTAUpdateCallable(const DeleteOTAUpdateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteOTAUpdate, request);
        }
 
        template<typename DeleteOTAUpdateRequestT = Model::DeleteOTAUpdateRequest>
        void DeleteOTAUpdateAsync(const DeleteOTAUpdateRequestT& request, const DeleteOTAUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteOTAUpdate, request, handler, context);
        }
 
        virtual Model::DeletePackageOutcome DeletePackage(const Model::DeletePackageRequest& request) const;
 
        template<typename DeletePackageRequestT = Model::DeletePackageRequest>
        Model::DeletePackageOutcomeCallable DeletePackageCallable(const DeletePackageRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeletePackage, request);
        }
 
        template<typename DeletePackageRequestT = Model::DeletePackageRequest>
        void DeletePackageAsync(const DeletePackageRequestT& request, const DeletePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeletePackage, request, handler, context);
        }
 
        virtual Model::DeletePackageVersionOutcome DeletePackageVersion(const Model::DeletePackageVersionRequest& request) const;
 
        template<typename DeletePackageVersionRequestT = Model::DeletePackageVersionRequest>
        Model::DeletePackageVersionOutcomeCallable DeletePackageVersionCallable(const DeletePackageVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeletePackageVersion, request);
        }
 
        template<typename DeletePackageVersionRequestT = Model::DeletePackageVersionRequest>
        void DeletePackageVersionAsync(const DeletePackageVersionRequestT& request, const DeletePackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeletePackageVersion, request, handler, context);
        }
 
        virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeletePolicy, request);
        }
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeletePolicy, request, handler, context);
        }
 
        virtual Model::DeletePolicyVersionOutcome DeletePolicyVersion(const Model::DeletePolicyVersionRequest& request) const;
 
        template<typename DeletePolicyVersionRequestT = Model::DeletePolicyVersionRequest>
        Model::DeletePolicyVersionOutcomeCallable DeletePolicyVersionCallable(const DeletePolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeletePolicyVersion, request);
        }
 
        template<typename DeletePolicyVersionRequestT = Model::DeletePolicyVersionRequest>
        void DeletePolicyVersionAsync(const DeletePolicyVersionRequestT& request, const DeletePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeletePolicyVersion, request, handler, context);
        }
 
        virtual Model::DeleteProvisioningTemplateOutcome DeleteProvisioningTemplate(const Model::DeleteProvisioningTemplateRequest& request) const;
 
        template<typename DeleteProvisioningTemplateRequestT = Model::DeleteProvisioningTemplateRequest>
        Model::DeleteProvisioningTemplateOutcomeCallable DeleteProvisioningTemplateCallable(const DeleteProvisioningTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteProvisioningTemplate, request);
        }
 
        template<typename DeleteProvisioningTemplateRequestT = Model::DeleteProvisioningTemplateRequest>
        void DeleteProvisioningTemplateAsync(const DeleteProvisioningTemplateRequestT& request, const DeleteProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteProvisioningTemplate, request, handler, context);
        }
 
        virtual Model::DeleteProvisioningTemplateVersionOutcome DeleteProvisioningTemplateVersion(const Model::DeleteProvisioningTemplateVersionRequest& request) const;
 
        template<typename DeleteProvisioningTemplateVersionRequestT = Model::DeleteProvisioningTemplateVersionRequest>
        Model::DeleteProvisioningTemplateVersionOutcomeCallable DeleteProvisioningTemplateVersionCallable(const DeleteProvisioningTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteProvisioningTemplateVersion, request);
        }
 
        template<typename DeleteProvisioningTemplateVersionRequestT = Model::DeleteProvisioningTemplateVersionRequest>
        void DeleteProvisioningTemplateVersionAsync(const DeleteProvisioningTemplateVersionRequestT& request, const DeleteProvisioningTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteProvisioningTemplateVersion, request, handler, context);
        }
 
        virtual Model::DeleteRegistrationCodeOutcome DeleteRegistrationCode(const Model::DeleteRegistrationCodeRequest& request = {}) const;
 
        template<typename DeleteRegistrationCodeRequestT = Model::DeleteRegistrationCodeRequest>
        Model::DeleteRegistrationCodeOutcomeCallable DeleteRegistrationCodeCallable(const DeleteRegistrationCodeRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DeleteRegistrationCode, request);
        }
 
        template<typename DeleteRegistrationCodeRequestT = Model::DeleteRegistrationCodeRequest>
        void DeleteRegistrationCodeAsync(const DeleteRegistrationCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteRegistrationCodeRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DeleteRegistrationCode, request, handler, context);
        }
 
        virtual Model::DeleteRoleAliasOutcome DeleteRoleAlias(const Model::DeleteRoleAliasRequest& request) const;
 
        template<typename DeleteRoleAliasRequestT = Model::DeleteRoleAliasRequest>
        Model::DeleteRoleAliasOutcomeCallable DeleteRoleAliasCallable(const DeleteRoleAliasRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteRoleAlias, request);
        }
 
        template<typename DeleteRoleAliasRequestT = Model::DeleteRoleAliasRequest>
        void DeleteRoleAliasAsync(const DeleteRoleAliasRequestT& request, const DeleteRoleAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteRoleAlias, request, handler, context);
        }
 
        virtual Model::DeleteScheduledAuditOutcome DeleteScheduledAudit(const Model::DeleteScheduledAuditRequest& request) const;
 
        template<typename DeleteScheduledAuditRequestT = Model::DeleteScheduledAuditRequest>
        Model::DeleteScheduledAuditOutcomeCallable DeleteScheduledAuditCallable(const DeleteScheduledAuditRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteScheduledAudit, request);
        }
 
        template<typename DeleteScheduledAuditRequestT = Model::DeleteScheduledAuditRequest>
        void DeleteScheduledAuditAsync(const DeleteScheduledAuditRequestT& request, const DeleteScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteScheduledAudit, request, handler, context);
        }
 
        virtual Model::DeleteSecurityProfileOutcome DeleteSecurityProfile(const Model::DeleteSecurityProfileRequest& request) const;
 
        template<typename DeleteSecurityProfileRequestT = Model::DeleteSecurityProfileRequest>
        Model::DeleteSecurityProfileOutcomeCallable DeleteSecurityProfileCallable(const DeleteSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteSecurityProfile, request);
        }
 
        template<typename DeleteSecurityProfileRequestT = Model::DeleteSecurityProfileRequest>
        void DeleteSecurityProfileAsync(const DeleteSecurityProfileRequestT& request, const DeleteSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteSecurityProfile, request, handler, context);
        }
 
        virtual Model::DeleteStreamOutcome DeleteStream(const Model::DeleteStreamRequest& request) const;
 
        template<typename DeleteStreamRequestT = Model::DeleteStreamRequest>
        Model::DeleteStreamOutcomeCallable DeleteStreamCallable(const DeleteStreamRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteStream, request);
        }
 
        template<typename DeleteStreamRequestT = Model::DeleteStreamRequest>
        void DeleteStreamAsync(const DeleteStreamRequestT& request, const DeleteStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteStream, request, handler, context);
        }
 
        virtual Model::DeleteThingOutcome DeleteThing(const Model::DeleteThingRequest& request) const;
 
        template<typename DeleteThingRequestT = Model::DeleteThingRequest>
        Model::DeleteThingOutcomeCallable DeleteThingCallable(const DeleteThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteThing, request);
        }
 
        template<typename DeleteThingRequestT = Model::DeleteThingRequest>
        void DeleteThingAsync(const DeleteThingRequestT& request, const DeleteThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteThing, request, handler, context);
        }
 
        virtual Model::DeleteThingGroupOutcome DeleteThingGroup(const Model::DeleteThingGroupRequest& request) const;
 
        template<typename DeleteThingGroupRequestT = Model::DeleteThingGroupRequest>
        Model::DeleteThingGroupOutcomeCallable DeleteThingGroupCallable(const DeleteThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteThingGroup, request);
        }
 
        template<typename DeleteThingGroupRequestT = Model::DeleteThingGroupRequest>
        void DeleteThingGroupAsync(const DeleteThingGroupRequestT& request, const DeleteThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteThingGroup, request, handler, context);
        }
 
        virtual Model::DeleteThingTypeOutcome DeleteThingType(const Model::DeleteThingTypeRequest& request) const;
 
        template<typename DeleteThingTypeRequestT = Model::DeleteThingTypeRequest>
        Model::DeleteThingTypeOutcomeCallable DeleteThingTypeCallable(const DeleteThingTypeRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteThingType, request);
        }
 
        template<typename DeleteThingTypeRequestT = Model::DeleteThingTypeRequest>
        void DeleteThingTypeAsync(const DeleteThingTypeRequestT& request, const DeleteThingTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteThingType, request, handler, context);
        }
 
        virtual Model::DeleteTopicRuleOutcome DeleteTopicRule(const Model::DeleteTopicRuleRequest& request) const;
 
        template<typename DeleteTopicRuleRequestT = Model::DeleteTopicRuleRequest>
        Model::DeleteTopicRuleOutcomeCallable DeleteTopicRuleCallable(const DeleteTopicRuleRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteTopicRule, request);
        }
 
        template<typename DeleteTopicRuleRequestT = Model::DeleteTopicRuleRequest>
        void DeleteTopicRuleAsync(const DeleteTopicRuleRequestT& request, const DeleteTopicRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteTopicRule, request, handler, context);
        }
 
        virtual Model::DeleteTopicRuleDestinationOutcome DeleteTopicRuleDestination(const Model::DeleteTopicRuleDestinationRequest& request) const;
 
        template<typename DeleteTopicRuleDestinationRequestT = Model::DeleteTopicRuleDestinationRequest>
        Model::DeleteTopicRuleDestinationOutcomeCallable DeleteTopicRuleDestinationCallable(const DeleteTopicRuleDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteTopicRuleDestination, request);
        }
 
        template<typename DeleteTopicRuleDestinationRequestT = Model::DeleteTopicRuleDestinationRequest>
        void DeleteTopicRuleDestinationAsync(const DeleteTopicRuleDestinationRequestT& request, const DeleteTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteTopicRuleDestination, request, handler, context);
        }
 
        virtual Model::DeleteV2LoggingLevelOutcome DeleteV2LoggingLevel(const Model::DeleteV2LoggingLevelRequest& request) const;
 
        template<typename DeleteV2LoggingLevelRequestT = Model::DeleteV2LoggingLevelRequest>
        Model::DeleteV2LoggingLevelOutcomeCallable DeleteV2LoggingLevelCallable(const DeleteV2LoggingLevelRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeleteV2LoggingLevel, request);
        }
 
        template<typename DeleteV2LoggingLevelRequestT = Model::DeleteV2LoggingLevelRequest>
        void DeleteV2LoggingLevelAsync(const DeleteV2LoggingLevelRequestT& request, const DeleteV2LoggingLevelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeleteV2LoggingLevel, request, handler, context);
        }
 
        virtual Model::DeprecateThingTypeOutcome DeprecateThingType(const Model::DeprecateThingTypeRequest& request) const;
 
        template<typename DeprecateThingTypeRequestT = Model::DeprecateThingTypeRequest>
        Model::DeprecateThingTypeOutcomeCallable DeprecateThingTypeCallable(const DeprecateThingTypeRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DeprecateThingType, request);
        }
 
        template<typename DeprecateThingTypeRequestT = Model::DeprecateThingTypeRequest>
        void DeprecateThingTypeAsync(const DeprecateThingTypeRequestT& request, const DeprecateThingTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DeprecateThingType, request, handler, context);
        }
 
        virtual Model::DescribeAccountAuditConfigurationOutcome DescribeAccountAuditConfiguration(const Model::DescribeAccountAuditConfigurationRequest& request = {}) const;
 
        template<typename DescribeAccountAuditConfigurationRequestT = Model::DescribeAccountAuditConfigurationRequest>
        Model::DescribeAccountAuditConfigurationOutcomeCallable DescribeAccountAuditConfigurationCallable(const DescribeAccountAuditConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DescribeAccountAuditConfiguration, request);
        }
 
        template<typename DescribeAccountAuditConfigurationRequestT = Model::DescribeAccountAuditConfigurationRequest>
        void DescribeAccountAuditConfigurationAsync(const DescribeAccountAuditConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountAuditConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DescribeAccountAuditConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeAuditFindingOutcome DescribeAuditFinding(const Model::DescribeAuditFindingRequest& request) const;
 
        template<typename DescribeAuditFindingRequestT = Model::DescribeAuditFindingRequest>
        Model::DescribeAuditFindingOutcomeCallable DescribeAuditFindingCallable(const DescribeAuditFindingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeAuditFinding, request);
        }
 
        template<typename DescribeAuditFindingRequestT = Model::DescribeAuditFindingRequest>
        void DescribeAuditFindingAsync(const DescribeAuditFindingRequestT& request, const DescribeAuditFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeAuditFinding, request, handler, context);
        }
 
        virtual Model::DescribeAuditMitigationActionsTaskOutcome DescribeAuditMitigationActionsTask(const Model::DescribeAuditMitigationActionsTaskRequest& request) const;
 
        template<typename DescribeAuditMitigationActionsTaskRequestT = Model::DescribeAuditMitigationActionsTaskRequest>
        Model::DescribeAuditMitigationActionsTaskOutcomeCallable DescribeAuditMitigationActionsTaskCallable(const DescribeAuditMitigationActionsTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeAuditMitigationActionsTask, request);
        }
 
        template<typename DescribeAuditMitigationActionsTaskRequestT = Model::DescribeAuditMitigationActionsTaskRequest>
        void DescribeAuditMitigationActionsTaskAsync(const DescribeAuditMitigationActionsTaskRequestT& request, const DescribeAuditMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeAuditMitigationActionsTask, request, handler, context);
        }
 
        virtual Model::DescribeAuditSuppressionOutcome DescribeAuditSuppression(const Model::DescribeAuditSuppressionRequest& request) const;
 
        template<typename DescribeAuditSuppressionRequestT = Model::DescribeAuditSuppressionRequest>
        Model::DescribeAuditSuppressionOutcomeCallable DescribeAuditSuppressionCallable(const DescribeAuditSuppressionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeAuditSuppression, request);
        }
 
        template<typename DescribeAuditSuppressionRequestT = Model::DescribeAuditSuppressionRequest>
        void DescribeAuditSuppressionAsync(const DescribeAuditSuppressionRequestT& request, const DescribeAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeAuditSuppression, request, handler, context);
        }
 
        virtual Model::DescribeAuditTaskOutcome DescribeAuditTask(const Model::DescribeAuditTaskRequest& request) const;
 
        template<typename DescribeAuditTaskRequestT = Model::DescribeAuditTaskRequest>
        Model::DescribeAuditTaskOutcomeCallable DescribeAuditTaskCallable(const DescribeAuditTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeAuditTask, request);
        }
 
        template<typename DescribeAuditTaskRequestT = Model::DescribeAuditTaskRequest>
        void DescribeAuditTaskAsync(const DescribeAuditTaskRequestT& request, const DescribeAuditTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeAuditTask, request, handler, context);
        }
 
        virtual Model::DescribeAuthorizerOutcome DescribeAuthorizer(const Model::DescribeAuthorizerRequest& request) const;
 
        template<typename DescribeAuthorizerRequestT = Model::DescribeAuthorizerRequest>
        Model::DescribeAuthorizerOutcomeCallable DescribeAuthorizerCallable(const DescribeAuthorizerRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeAuthorizer, request);
        }
 
        template<typename DescribeAuthorizerRequestT = Model::DescribeAuthorizerRequest>
        void DescribeAuthorizerAsync(const DescribeAuthorizerRequestT& request, const DescribeAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeAuthorizer, request, handler, context);
        }
 
        virtual Model::DescribeBillingGroupOutcome DescribeBillingGroup(const Model::DescribeBillingGroupRequest& request) const;
 
        template<typename DescribeBillingGroupRequestT = Model::DescribeBillingGroupRequest>
        Model::DescribeBillingGroupOutcomeCallable DescribeBillingGroupCallable(const DescribeBillingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeBillingGroup, request);
        }
 
        template<typename DescribeBillingGroupRequestT = Model::DescribeBillingGroupRequest>
        void DescribeBillingGroupAsync(const DescribeBillingGroupRequestT& request, const DescribeBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeBillingGroup, request, handler, context);
        }
 
        virtual Model::DescribeCACertificateOutcome DescribeCACertificate(const Model::DescribeCACertificateRequest& request) const;
 
        template<typename DescribeCACertificateRequestT = Model::DescribeCACertificateRequest>
        Model::DescribeCACertificateOutcomeCallable DescribeCACertificateCallable(const DescribeCACertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeCACertificate, request);
        }
 
        template<typename DescribeCACertificateRequestT = Model::DescribeCACertificateRequest>
        void DescribeCACertificateAsync(const DescribeCACertificateRequestT& request, const DescribeCACertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeCACertificate, request, handler, context);
        }
 
        virtual Model::DescribeCertificateOutcome DescribeCertificate(const Model::DescribeCertificateRequest& request) const;
 
        template<typename DescribeCertificateRequestT = Model::DescribeCertificateRequest>
        Model::DescribeCertificateOutcomeCallable DescribeCertificateCallable(const DescribeCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeCertificate, request);
        }
 
        template<typename DescribeCertificateRequestT = Model::DescribeCertificateRequest>
        void DescribeCertificateAsync(const DescribeCertificateRequestT& request, const DescribeCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeCertificate, request, handler, context);
        }
 
        virtual Model::DescribeCertificateProviderOutcome DescribeCertificateProvider(const Model::DescribeCertificateProviderRequest& request) const;
 
        template<typename DescribeCertificateProviderRequestT = Model::DescribeCertificateProviderRequest>
        Model::DescribeCertificateProviderOutcomeCallable DescribeCertificateProviderCallable(const DescribeCertificateProviderRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeCertificateProvider, request);
        }
 
        template<typename DescribeCertificateProviderRequestT = Model::DescribeCertificateProviderRequest>
        void DescribeCertificateProviderAsync(const DescribeCertificateProviderRequestT& request, const DescribeCertificateProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeCertificateProvider, request, handler, context);
        }
 
        virtual Model::DescribeCustomMetricOutcome DescribeCustomMetric(const Model::DescribeCustomMetricRequest& request) const;
 
        template<typename DescribeCustomMetricRequestT = Model::DescribeCustomMetricRequest>
        Model::DescribeCustomMetricOutcomeCallable DescribeCustomMetricCallable(const DescribeCustomMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeCustomMetric, request);
        }
 
        template<typename DescribeCustomMetricRequestT = Model::DescribeCustomMetricRequest>
        void DescribeCustomMetricAsync(const DescribeCustomMetricRequestT& request, const DescribeCustomMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeCustomMetric, request, handler, context);
        }
 
        virtual Model::DescribeDefaultAuthorizerOutcome DescribeDefaultAuthorizer(const Model::DescribeDefaultAuthorizerRequest& request = {}) const;
 
        template<typename DescribeDefaultAuthorizerRequestT = Model::DescribeDefaultAuthorizerRequest>
        Model::DescribeDefaultAuthorizerOutcomeCallable DescribeDefaultAuthorizerCallable(const DescribeDefaultAuthorizerRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DescribeDefaultAuthorizer, request);
        }
 
        template<typename DescribeDefaultAuthorizerRequestT = Model::DescribeDefaultAuthorizerRequest>
        void DescribeDefaultAuthorizerAsync(const DescribeDefaultAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeDefaultAuthorizerRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DescribeDefaultAuthorizer, request, handler, context);
        }
 
        virtual Model::DescribeDetectMitigationActionsTaskOutcome DescribeDetectMitigationActionsTask(const Model::DescribeDetectMitigationActionsTaskRequest& request) const;
 
        template<typename DescribeDetectMitigationActionsTaskRequestT = Model::DescribeDetectMitigationActionsTaskRequest>
        Model::DescribeDetectMitigationActionsTaskOutcomeCallable DescribeDetectMitigationActionsTaskCallable(const DescribeDetectMitigationActionsTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeDetectMitigationActionsTask, request);
        }
 
        template<typename DescribeDetectMitigationActionsTaskRequestT = Model::DescribeDetectMitigationActionsTaskRequest>
        void DescribeDetectMitigationActionsTaskAsync(const DescribeDetectMitigationActionsTaskRequestT& request, const DescribeDetectMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeDetectMitigationActionsTask, request, handler, context);
        }
 
        virtual Model::DescribeDimensionOutcome DescribeDimension(const Model::DescribeDimensionRequest& request) const;
 
        template<typename DescribeDimensionRequestT = Model::DescribeDimensionRequest>
        Model::DescribeDimensionOutcomeCallable DescribeDimensionCallable(const DescribeDimensionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeDimension, request);
        }
 
        template<typename DescribeDimensionRequestT = Model::DescribeDimensionRequest>
        void DescribeDimensionAsync(const DescribeDimensionRequestT& request, const DescribeDimensionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeDimension, request, handler, context);
        }
 
        virtual Model::DescribeDomainConfigurationOutcome DescribeDomainConfiguration(const Model::DescribeDomainConfigurationRequest& request) const;
 
        template<typename DescribeDomainConfigurationRequestT = Model::DescribeDomainConfigurationRequest>
        Model::DescribeDomainConfigurationOutcomeCallable DescribeDomainConfigurationCallable(const DescribeDomainConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeDomainConfiguration, request);
        }
 
        template<typename DescribeDomainConfigurationRequestT = Model::DescribeDomainConfigurationRequest>
        void DescribeDomainConfigurationAsync(const DescribeDomainConfigurationRequestT& request, const DescribeDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeDomainConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeEncryptionConfigurationOutcome DescribeEncryptionConfiguration(const Model::DescribeEncryptionConfigurationRequest& request = {}) const;
 
        template<typename DescribeEncryptionConfigurationRequestT = Model::DescribeEncryptionConfigurationRequest>
        Model::DescribeEncryptionConfigurationOutcomeCallable DescribeEncryptionConfigurationCallable(const DescribeEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DescribeEncryptionConfiguration, request);
        }
 
        template<typename DescribeEncryptionConfigurationRequestT = Model::DescribeEncryptionConfigurationRequest>
        void DescribeEncryptionConfigurationAsync(const DescribeEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEncryptionConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DescribeEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::DescribeEndpointOutcome DescribeEndpoint(const Model::DescribeEndpointRequest& request = {}) const;
 
        template<typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
        Model::DescribeEndpointOutcomeCallable DescribeEndpointCallable(const DescribeEndpointRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DescribeEndpoint, request);
        }
 
        template<typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
        void DescribeEndpointAsync(const DescribeEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEndpointRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DescribeEndpoint, request, handler, context);
        }
 
        virtual Model::DescribeEventConfigurationsOutcome DescribeEventConfigurations(const Model::DescribeEventConfigurationsRequest& request = {}) const;
 
        template<typename DescribeEventConfigurationsRequestT = Model::DescribeEventConfigurationsRequest>
        Model::DescribeEventConfigurationsOutcomeCallable DescribeEventConfigurationsCallable(const DescribeEventConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::DescribeEventConfigurations, request);
        }
 
        template<typename DescribeEventConfigurationsRequestT = Model::DescribeEventConfigurationsRequest>
        void DescribeEventConfigurationsAsync(const DescribeEventConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeEventConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::DescribeEventConfigurations, request, handler, context);
        }
 
        virtual Model::DescribeFleetMetricOutcome DescribeFleetMetric(const Model::DescribeFleetMetricRequest& request) const;
 
        template<typename DescribeFleetMetricRequestT = Model::DescribeFleetMetricRequest>
        Model::DescribeFleetMetricOutcomeCallable DescribeFleetMetricCallable(const DescribeFleetMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeFleetMetric, request);
        }
 
        template<typename DescribeFleetMetricRequestT = Model::DescribeFleetMetricRequest>
        void DescribeFleetMetricAsync(const DescribeFleetMetricRequestT& request, const DescribeFleetMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeFleetMetric, request, handler, context);
        }
 
        virtual Model::DescribeIndexOutcome DescribeIndex(const Model::DescribeIndexRequest& request) const;
 
        template<typename DescribeIndexRequestT = Model::DescribeIndexRequest>
        Model::DescribeIndexOutcomeCallable DescribeIndexCallable(const DescribeIndexRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeIndex, request);
        }
 
        template<typename DescribeIndexRequestT = Model::DescribeIndexRequest>
        void DescribeIndexAsync(const DescribeIndexRequestT& request, const DescribeIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeIndex, request, handler, context);
        }
 
        virtual Model::DescribeJobOutcome DescribeJob(const Model::DescribeJobRequest& request) const;
 
        template<typename DescribeJobRequestT = Model::DescribeJobRequest>
        Model::DescribeJobOutcomeCallable DescribeJobCallable(const DescribeJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeJob, request);
        }
 
        template<typename DescribeJobRequestT = Model::DescribeJobRequest>
        void DescribeJobAsync(const DescribeJobRequestT& request, const DescribeJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeJob, request, handler, context);
        }
 
        virtual Model::DescribeJobExecutionOutcome DescribeJobExecution(const Model::DescribeJobExecutionRequest& request) const;
 
        template<typename DescribeJobExecutionRequestT = Model::DescribeJobExecutionRequest>
        Model::DescribeJobExecutionOutcomeCallable DescribeJobExecutionCallable(const DescribeJobExecutionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeJobExecution, request);
        }
 
        template<typename DescribeJobExecutionRequestT = Model::DescribeJobExecutionRequest>
        void DescribeJobExecutionAsync(const DescribeJobExecutionRequestT& request, const DescribeJobExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeJobExecution, request, handler, context);
        }
 
        virtual Model::DescribeJobTemplateOutcome DescribeJobTemplate(const Model::DescribeJobTemplateRequest& request) const;
 
        template<typename DescribeJobTemplateRequestT = Model::DescribeJobTemplateRequest>
        Model::DescribeJobTemplateOutcomeCallable DescribeJobTemplateCallable(const DescribeJobTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeJobTemplate, request);
        }
 
        template<typename DescribeJobTemplateRequestT = Model::DescribeJobTemplateRequest>
        void DescribeJobTemplateAsync(const DescribeJobTemplateRequestT& request, const DescribeJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeJobTemplate, request, handler, context);
        }
 
        virtual Model::DescribeManagedJobTemplateOutcome DescribeManagedJobTemplate(const Model::DescribeManagedJobTemplateRequest& request) const;
 
        template<typename DescribeManagedJobTemplateRequestT = Model::DescribeManagedJobTemplateRequest>
        Model::DescribeManagedJobTemplateOutcomeCallable DescribeManagedJobTemplateCallable(const DescribeManagedJobTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeManagedJobTemplate, request);
        }
 
        template<typename DescribeManagedJobTemplateRequestT = Model::DescribeManagedJobTemplateRequest>
        void DescribeManagedJobTemplateAsync(const DescribeManagedJobTemplateRequestT& request, const DescribeManagedJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeManagedJobTemplate, request, handler, context);
        }
 
        virtual Model::DescribeMitigationActionOutcome DescribeMitigationAction(const Model::DescribeMitigationActionRequest& request) const;
 
        template<typename DescribeMitigationActionRequestT = Model::DescribeMitigationActionRequest>
        Model::DescribeMitigationActionOutcomeCallable DescribeMitigationActionCallable(const DescribeMitigationActionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeMitigationAction, request);
        }
 
        template<typename DescribeMitigationActionRequestT = Model::DescribeMitigationActionRequest>
        void DescribeMitigationActionAsync(const DescribeMitigationActionRequestT& request, const DescribeMitigationActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeMitigationAction, request, handler, context);
        }
 
        virtual Model::DescribeProvisioningTemplateOutcome DescribeProvisioningTemplate(const Model::DescribeProvisioningTemplateRequest& request) const;
 
        template<typename DescribeProvisioningTemplateRequestT = Model::DescribeProvisioningTemplateRequest>
        Model::DescribeProvisioningTemplateOutcomeCallable DescribeProvisioningTemplateCallable(const DescribeProvisioningTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeProvisioningTemplate, request);
        }
 
        template<typename DescribeProvisioningTemplateRequestT = Model::DescribeProvisioningTemplateRequest>
        void DescribeProvisioningTemplateAsync(const DescribeProvisioningTemplateRequestT& request, const DescribeProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeProvisioningTemplate, request, handler, context);
        }
 
        virtual Model::DescribeProvisioningTemplateVersionOutcome DescribeProvisioningTemplateVersion(const Model::DescribeProvisioningTemplateVersionRequest& request) const;
 
        template<typename DescribeProvisioningTemplateVersionRequestT = Model::DescribeProvisioningTemplateVersionRequest>
        Model::DescribeProvisioningTemplateVersionOutcomeCallable DescribeProvisioningTemplateVersionCallable(const DescribeProvisioningTemplateVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeProvisioningTemplateVersion, request);
        }
 
        template<typename DescribeProvisioningTemplateVersionRequestT = Model::DescribeProvisioningTemplateVersionRequest>
        void DescribeProvisioningTemplateVersionAsync(const DescribeProvisioningTemplateVersionRequestT& request, const DescribeProvisioningTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeProvisioningTemplateVersion, request, handler, context);
        }
 
        virtual Model::DescribeRoleAliasOutcome DescribeRoleAlias(const Model::DescribeRoleAliasRequest& request) const;
 
        template<typename DescribeRoleAliasRequestT = Model::DescribeRoleAliasRequest>
        Model::DescribeRoleAliasOutcomeCallable DescribeRoleAliasCallable(const DescribeRoleAliasRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeRoleAlias, request);
        }
 
        template<typename DescribeRoleAliasRequestT = Model::DescribeRoleAliasRequest>
        void DescribeRoleAliasAsync(const DescribeRoleAliasRequestT& request, const DescribeRoleAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeRoleAlias, request, handler, context);
        }
 
        virtual Model::DescribeScheduledAuditOutcome DescribeScheduledAudit(const Model::DescribeScheduledAuditRequest& request) const;
 
        template<typename DescribeScheduledAuditRequestT = Model::DescribeScheduledAuditRequest>
        Model::DescribeScheduledAuditOutcomeCallable DescribeScheduledAuditCallable(const DescribeScheduledAuditRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeScheduledAudit, request);
        }
 
        template<typename DescribeScheduledAuditRequestT = Model::DescribeScheduledAuditRequest>
        void DescribeScheduledAuditAsync(const DescribeScheduledAuditRequestT& request, const DescribeScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeScheduledAudit, request, handler, context);
        }
 
        virtual Model::DescribeSecurityProfileOutcome DescribeSecurityProfile(const Model::DescribeSecurityProfileRequest& request) const;
 
        template<typename DescribeSecurityProfileRequestT = Model::DescribeSecurityProfileRequest>
        Model::DescribeSecurityProfileOutcomeCallable DescribeSecurityProfileCallable(const DescribeSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeSecurityProfile, request);
        }
 
        template<typename DescribeSecurityProfileRequestT = Model::DescribeSecurityProfileRequest>
        void DescribeSecurityProfileAsync(const DescribeSecurityProfileRequestT& request, const DescribeSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeSecurityProfile, request, handler, context);
        }
 
        virtual Model::DescribeStreamOutcome DescribeStream(const Model::DescribeStreamRequest& request) const;
 
        template<typename DescribeStreamRequestT = Model::DescribeStreamRequest>
        Model::DescribeStreamOutcomeCallable DescribeStreamCallable(const DescribeStreamRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeStream, request);
        }
 
        template<typename DescribeStreamRequestT = Model::DescribeStreamRequest>
        void DescribeStreamAsync(const DescribeStreamRequestT& request, const DescribeStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeStream, request, handler, context);
        }
 
        virtual Model::DescribeThingOutcome DescribeThing(const Model::DescribeThingRequest& request) const;
 
        template<typename DescribeThingRequestT = Model::DescribeThingRequest>
        Model::DescribeThingOutcomeCallable DescribeThingCallable(const DescribeThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeThing, request);
        }
 
        template<typename DescribeThingRequestT = Model::DescribeThingRequest>
        void DescribeThingAsync(const DescribeThingRequestT& request, const DescribeThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeThing, request, handler, context);
        }
 
        virtual Model::DescribeThingGroupOutcome DescribeThingGroup(const Model::DescribeThingGroupRequest& request) const;
 
        template<typename DescribeThingGroupRequestT = Model::DescribeThingGroupRequest>
        Model::DescribeThingGroupOutcomeCallable DescribeThingGroupCallable(const DescribeThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeThingGroup, request);
        }
 
        template<typename DescribeThingGroupRequestT = Model::DescribeThingGroupRequest>
        void DescribeThingGroupAsync(const DescribeThingGroupRequestT& request, const DescribeThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeThingGroup, request, handler, context);
        }
 
        virtual Model::DescribeThingRegistrationTaskOutcome DescribeThingRegistrationTask(const Model::DescribeThingRegistrationTaskRequest& request) const;
 
        template<typename DescribeThingRegistrationTaskRequestT = Model::DescribeThingRegistrationTaskRequest>
        Model::DescribeThingRegistrationTaskOutcomeCallable DescribeThingRegistrationTaskCallable(const DescribeThingRegistrationTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeThingRegistrationTask, request);
        }
 
        template<typename DescribeThingRegistrationTaskRequestT = Model::DescribeThingRegistrationTaskRequest>
        void DescribeThingRegistrationTaskAsync(const DescribeThingRegistrationTaskRequestT& request, const DescribeThingRegistrationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeThingRegistrationTask, request, handler, context);
        }
 
        virtual Model::DescribeThingTypeOutcome DescribeThingType(const Model::DescribeThingTypeRequest& request) const;
 
        template<typename DescribeThingTypeRequestT = Model::DescribeThingTypeRequest>
        Model::DescribeThingTypeOutcomeCallable DescribeThingTypeCallable(const DescribeThingTypeRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DescribeThingType, request);
        }
 
        template<typename DescribeThingTypeRequestT = Model::DescribeThingTypeRequest>
        void DescribeThingTypeAsync(const DescribeThingTypeRequestT& request, const DescribeThingTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DescribeThingType, request, handler, context);
        }
 
        virtual Model::DetachPolicyOutcome DetachPolicy(const Model::DetachPolicyRequest& request) const;
 
        template<typename DetachPolicyRequestT = Model::DetachPolicyRequest>
        Model::DetachPolicyOutcomeCallable DetachPolicyCallable(const DetachPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DetachPolicy, request);
        }
 
        template<typename DetachPolicyRequestT = Model::DetachPolicyRequest>
        void DetachPolicyAsync(const DetachPolicyRequestT& request, const DetachPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DetachPolicy, request, handler, context);
        }
 
        virtual Model::DetachSecurityProfileOutcome DetachSecurityProfile(const Model::DetachSecurityProfileRequest& request) const;
 
        template<typename DetachSecurityProfileRequestT = Model::DetachSecurityProfileRequest>
        Model::DetachSecurityProfileOutcomeCallable DetachSecurityProfileCallable(const DetachSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DetachSecurityProfile, request);
        }
 
        template<typename DetachSecurityProfileRequestT = Model::DetachSecurityProfileRequest>
        void DetachSecurityProfileAsync(const DetachSecurityProfileRequestT& request, const DetachSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DetachSecurityProfile, request, handler, context);
        }
 
        virtual Model::DetachThingPrincipalOutcome DetachThingPrincipal(const Model::DetachThingPrincipalRequest& request) const;
 
        template<typename DetachThingPrincipalRequestT = Model::DetachThingPrincipalRequest>
        Model::DetachThingPrincipalOutcomeCallable DetachThingPrincipalCallable(const DetachThingPrincipalRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DetachThingPrincipal, request);
        }
 
        template<typename DetachThingPrincipalRequestT = Model::DetachThingPrincipalRequest>
        void DetachThingPrincipalAsync(const DetachThingPrincipalRequestT& request, const DetachThingPrincipalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DetachThingPrincipal, request, handler, context);
        }
 
        virtual Model::DisableTopicRuleOutcome DisableTopicRule(const Model::DisableTopicRuleRequest& request) const;
 
        template<typename DisableTopicRuleRequestT = Model::DisableTopicRuleRequest>
        Model::DisableTopicRuleOutcomeCallable DisableTopicRuleCallable(const DisableTopicRuleRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DisableTopicRule, request);
        }
 
        template<typename DisableTopicRuleRequestT = Model::DisableTopicRuleRequest>
        void DisableTopicRuleAsync(const DisableTopicRuleRequestT& request, const DisableTopicRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DisableTopicRule, request, handler, context);
        }
 
        virtual Model::DisassociateSbomFromPackageVersionOutcome DisassociateSbomFromPackageVersion(const Model::DisassociateSbomFromPackageVersionRequest& request) const;
 
        template<typename DisassociateSbomFromPackageVersionRequestT = Model::DisassociateSbomFromPackageVersionRequest>
        Model::DisassociateSbomFromPackageVersionOutcomeCallable DisassociateSbomFromPackageVersionCallable(const DisassociateSbomFromPackageVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::DisassociateSbomFromPackageVersion, request);
        }
 
        template<typename DisassociateSbomFromPackageVersionRequestT = Model::DisassociateSbomFromPackageVersionRequest>
        void DisassociateSbomFromPackageVersionAsync(const DisassociateSbomFromPackageVersionRequestT& request, const DisassociateSbomFromPackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::DisassociateSbomFromPackageVersion, request, handler, context);
        }
 
        virtual Model::EnableTopicRuleOutcome EnableTopicRule(const Model::EnableTopicRuleRequest& request) const;
 
        template<typename EnableTopicRuleRequestT = Model::EnableTopicRuleRequest>
        Model::EnableTopicRuleOutcomeCallable EnableTopicRuleCallable(const EnableTopicRuleRequestT& request) const
        {
            return SubmitCallable(&IoTClient::EnableTopicRule, request);
        }
 
        template<typename EnableTopicRuleRequestT = Model::EnableTopicRuleRequest>
        void EnableTopicRuleAsync(const EnableTopicRuleRequestT& request, const EnableTopicRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::EnableTopicRule, request, handler, context);
        }
 
        virtual Model::GetBehaviorModelTrainingSummariesOutcome GetBehaviorModelTrainingSummaries(const Model::GetBehaviorModelTrainingSummariesRequest& request = {}) const;
 
        template<typename GetBehaviorModelTrainingSummariesRequestT = Model::GetBehaviorModelTrainingSummariesRequest>
        Model::GetBehaviorModelTrainingSummariesOutcomeCallable GetBehaviorModelTrainingSummariesCallable(const GetBehaviorModelTrainingSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetBehaviorModelTrainingSummaries, request);
        }
 
        template<typename GetBehaviorModelTrainingSummariesRequestT = Model::GetBehaviorModelTrainingSummariesRequest>
        void GetBehaviorModelTrainingSummariesAsync(const GetBehaviorModelTrainingSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetBehaviorModelTrainingSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetBehaviorModelTrainingSummaries, request, handler, context);
        }
 
        virtual Model::GetBucketsAggregationOutcome GetBucketsAggregation(const Model::GetBucketsAggregationRequest& request) const;
 
        template<typename GetBucketsAggregationRequestT = Model::GetBucketsAggregationRequest>
        Model::GetBucketsAggregationOutcomeCallable GetBucketsAggregationCallable(const GetBucketsAggregationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetBucketsAggregation, request);
        }
 
        template<typename GetBucketsAggregationRequestT = Model::GetBucketsAggregationRequest>
        void GetBucketsAggregationAsync(const GetBucketsAggregationRequestT& request, const GetBucketsAggregationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetBucketsAggregation, request, handler, context);
        }
 
        virtual Model::GetCardinalityOutcome GetCardinality(const Model::GetCardinalityRequest& request) const;
 
        template<typename GetCardinalityRequestT = Model::GetCardinalityRequest>
        Model::GetCardinalityOutcomeCallable GetCardinalityCallable(const GetCardinalityRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetCardinality, request);
        }
 
        template<typename GetCardinalityRequestT = Model::GetCardinalityRequest>
        void GetCardinalityAsync(const GetCardinalityRequestT& request, const GetCardinalityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetCardinality, request, handler, context);
        }
 
        virtual Model::GetCommandOutcome GetCommand(const Model::GetCommandRequest& request) const;
 
        template<typename GetCommandRequestT = Model::GetCommandRequest>
        Model::GetCommandOutcomeCallable GetCommandCallable(const GetCommandRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetCommand, request);
        }
 
        template<typename GetCommandRequestT = Model::GetCommandRequest>
        void GetCommandAsync(const GetCommandRequestT& request, const GetCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetCommand, request, handler, context);
        }
 
        virtual Model::GetCommandExecutionOutcome GetCommandExecution(const Model::GetCommandExecutionRequest& request) const;
 
        template<typename GetCommandExecutionRequestT = Model::GetCommandExecutionRequest>
        Model::GetCommandExecutionOutcomeCallable GetCommandExecutionCallable(const GetCommandExecutionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetCommandExecution, request);
        }
 
        template<typename GetCommandExecutionRequestT = Model::GetCommandExecutionRequest>
        void GetCommandExecutionAsync(const GetCommandExecutionRequestT& request, const GetCommandExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetCommandExecution, request, handler, context);
        }
 
        virtual Model::GetEffectivePoliciesOutcome GetEffectivePolicies(const Model::GetEffectivePoliciesRequest& request = {}) const;
 
        template<typename GetEffectivePoliciesRequestT = Model::GetEffectivePoliciesRequest>
        Model::GetEffectivePoliciesOutcomeCallable GetEffectivePoliciesCallable(const GetEffectivePoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetEffectivePolicies, request);
        }
 
        template<typename GetEffectivePoliciesRequestT = Model::GetEffectivePoliciesRequest>
        void GetEffectivePoliciesAsync(const GetEffectivePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetEffectivePoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetEffectivePolicies, request, handler, context);
        }
 
        virtual Model::GetIndexingConfigurationOutcome GetIndexingConfiguration(const Model::GetIndexingConfigurationRequest& request = {}) const;
 
        template<typename GetIndexingConfigurationRequestT = Model::GetIndexingConfigurationRequest>
        Model::GetIndexingConfigurationOutcomeCallable GetIndexingConfigurationCallable(const GetIndexingConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetIndexingConfiguration, request);
        }
 
        template<typename GetIndexingConfigurationRequestT = Model::GetIndexingConfigurationRequest>
        void GetIndexingConfigurationAsync(const GetIndexingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetIndexingConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetIndexingConfiguration, request, handler, context);
        }
 
        virtual Model::GetJobDocumentOutcome GetJobDocument(const Model::GetJobDocumentRequest& request) const;
 
        template<typename GetJobDocumentRequestT = Model::GetJobDocumentRequest>
        Model::GetJobDocumentOutcomeCallable GetJobDocumentCallable(const GetJobDocumentRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetJobDocument, request);
        }
 
        template<typename GetJobDocumentRequestT = Model::GetJobDocumentRequest>
        void GetJobDocumentAsync(const GetJobDocumentRequestT& request, const GetJobDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetJobDocument, request, handler, context);
        }
 
        virtual Model::GetLoggingOptionsOutcome GetLoggingOptions(const Model::GetLoggingOptionsRequest& request = {}) const;
 
        template<typename GetLoggingOptionsRequestT = Model::GetLoggingOptionsRequest>
        Model::GetLoggingOptionsOutcomeCallable GetLoggingOptionsCallable(const GetLoggingOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetLoggingOptions, request);
        }
 
        template<typename GetLoggingOptionsRequestT = Model::GetLoggingOptionsRequest>
        void GetLoggingOptionsAsync(const GetLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetLoggingOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetLoggingOptions, request, handler, context);
        }
 
        virtual Model::GetOTAUpdateOutcome GetOTAUpdate(const Model::GetOTAUpdateRequest& request) const;
 
        template<typename GetOTAUpdateRequestT = Model::GetOTAUpdateRequest>
        Model::GetOTAUpdateOutcomeCallable GetOTAUpdateCallable(const GetOTAUpdateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetOTAUpdate, request);
        }
 
        template<typename GetOTAUpdateRequestT = Model::GetOTAUpdateRequest>
        void GetOTAUpdateAsync(const GetOTAUpdateRequestT& request, const GetOTAUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetOTAUpdate, request, handler, context);
        }
 
        virtual Model::GetPackageOutcome GetPackage(const Model::GetPackageRequest& request) const;
 
        template<typename GetPackageRequestT = Model::GetPackageRequest>
        Model::GetPackageOutcomeCallable GetPackageCallable(const GetPackageRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetPackage, request);
        }
 
        template<typename GetPackageRequestT = Model::GetPackageRequest>
        void GetPackageAsync(const GetPackageRequestT& request, const GetPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetPackage, request, handler, context);
        }
 
        virtual Model::GetPackageConfigurationOutcome GetPackageConfiguration(const Model::GetPackageConfigurationRequest& request = {}) const;
 
        template<typename GetPackageConfigurationRequestT = Model::GetPackageConfigurationRequest>
        Model::GetPackageConfigurationOutcomeCallable GetPackageConfigurationCallable(const GetPackageConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetPackageConfiguration, request);
        }
 
        template<typename GetPackageConfigurationRequestT = Model::GetPackageConfigurationRequest>
        void GetPackageConfigurationAsync(const GetPackageConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetPackageConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetPackageConfiguration, request, handler, context);
        }
 
        virtual Model::GetPackageVersionOutcome GetPackageVersion(const Model::GetPackageVersionRequest& request) const;
 
        template<typename GetPackageVersionRequestT = Model::GetPackageVersionRequest>
        Model::GetPackageVersionOutcomeCallable GetPackageVersionCallable(const GetPackageVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetPackageVersion, request);
        }
 
        template<typename GetPackageVersionRequestT = Model::GetPackageVersionRequest>
        void GetPackageVersionAsync(const GetPackageVersionRequestT& request, const GetPackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetPackageVersion, request, handler, context);
        }
 
        virtual Model::GetPercentilesOutcome GetPercentiles(const Model::GetPercentilesRequest& request) const;
 
        template<typename GetPercentilesRequestT = Model::GetPercentilesRequest>
        Model::GetPercentilesOutcomeCallable GetPercentilesCallable(const GetPercentilesRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetPercentiles, request);
        }
 
        template<typename GetPercentilesRequestT = Model::GetPercentilesRequest>
        void GetPercentilesAsync(const GetPercentilesRequestT& request, const GetPercentilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetPercentiles, request, handler, context);
        }
 
        virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const;
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetPolicy, request);
        }
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetPolicy, request, handler, context);
        }
 
        virtual Model::GetPolicyVersionOutcome GetPolicyVersion(const Model::GetPolicyVersionRequest& request) const;
 
        template<typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
        Model::GetPolicyVersionOutcomeCallable GetPolicyVersionCallable(const GetPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetPolicyVersion, request);
        }
 
        template<typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
        void GetPolicyVersionAsync(const GetPolicyVersionRequestT& request, const GetPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetPolicyVersion, request, handler, context);
        }
 
        virtual Model::GetRegistrationCodeOutcome GetRegistrationCode(const Model::GetRegistrationCodeRequest& request = {}) const;
 
        template<typename GetRegistrationCodeRequestT = Model::GetRegistrationCodeRequest>
        Model::GetRegistrationCodeOutcomeCallable GetRegistrationCodeCallable(const GetRegistrationCodeRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetRegistrationCode, request);
        }
 
        template<typename GetRegistrationCodeRequestT = Model::GetRegistrationCodeRequest>
        void GetRegistrationCodeAsync(const GetRegistrationCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetRegistrationCodeRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetRegistrationCode, request, handler, context);
        }
 
        virtual Model::GetStatisticsOutcome GetStatistics(const Model::GetStatisticsRequest& request) const;
 
        template<typename GetStatisticsRequestT = Model::GetStatisticsRequest>
        Model::GetStatisticsOutcomeCallable GetStatisticsCallable(const GetStatisticsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetStatistics, request);
        }
 
        template<typename GetStatisticsRequestT = Model::GetStatisticsRequest>
        void GetStatisticsAsync(const GetStatisticsRequestT& request, const GetStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetStatistics, request, handler, context);
        }
 
        virtual Model::GetThingConnectivityDataOutcome GetThingConnectivityData(const Model::GetThingConnectivityDataRequest& request) const;
 
        template<typename GetThingConnectivityDataRequestT = Model::GetThingConnectivityDataRequest>
        Model::GetThingConnectivityDataOutcomeCallable GetThingConnectivityDataCallable(const GetThingConnectivityDataRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetThingConnectivityData, request);
        }
 
        template<typename GetThingConnectivityDataRequestT = Model::GetThingConnectivityDataRequest>
        void GetThingConnectivityDataAsync(const GetThingConnectivityDataRequestT& request, const GetThingConnectivityDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetThingConnectivityData, request, handler, context);
        }
 
        virtual Model::GetTopicRuleOutcome GetTopicRule(const Model::GetTopicRuleRequest& request) const;
 
        template<typename GetTopicRuleRequestT = Model::GetTopicRuleRequest>
        Model::GetTopicRuleOutcomeCallable GetTopicRuleCallable(const GetTopicRuleRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetTopicRule, request);
        }
 
        template<typename GetTopicRuleRequestT = Model::GetTopicRuleRequest>
        void GetTopicRuleAsync(const GetTopicRuleRequestT& request, const GetTopicRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetTopicRule, request, handler, context);
        }
 
        virtual Model::GetTopicRuleDestinationOutcome GetTopicRuleDestination(const Model::GetTopicRuleDestinationRequest& request) const;
 
        template<typename GetTopicRuleDestinationRequestT = Model::GetTopicRuleDestinationRequest>
        Model::GetTopicRuleDestinationOutcomeCallable GetTopicRuleDestinationCallable(const GetTopicRuleDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::GetTopicRuleDestination, request);
        }
 
        template<typename GetTopicRuleDestinationRequestT = Model::GetTopicRuleDestinationRequest>
        void GetTopicRuleDestinationAsync(const GetTopicRuleDestinationRequestT& request, const GetTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::GetTopicRuleDestination, request, handler, context);
        }
 
        virtual Model::GetV2LoggingOptionsOutcome GetV2LoggingOptions(const Model::GetV2LoggingOptionsRequest& request = {}) const;
 
        template<typename GetV2LoggingOptionsRequestT = Model::GetV2LoggingOptionsRequest>
        Model::GetV2LoggingOptionsOutcomeCallable GetV2LoggingOptionsCallable(const GetV2LoggingOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::GetV2LoggingOptions, request);
        }
 
        template<typename GetV2LoggingOptionsRequestT = Model::GetV2LoggingOptionsRequest>
        void GetV2LoggingOptionsAsync(const GetV2LoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetV2LoggingOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::GetV2LoggingOptions, request, handler, context);
        }
 
        virtual Model::ListActiveViolationsOutcome ListActiveViolations(const Model::ListActiveViolationsRequest& request = {}) const;
 
        template<typename ListActiveViolationsRequestT = Model::ListActiveViolationsRequest>
        Model::ListActiveViolationsOutcomeCallable ListActiveViolationsCallable(const ListActiveViolationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListActiveViolations, request);
        }
 
        template<typename ListActiveViolationsRequestT = Model::ListActiveViolationsRequest>
        void ListActiveViolationsAsync(const ListActiveViolationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListActiveViolationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListActiveViolations, request, handler, context);
        }
 
        virtual Model::ListAttachedPoliciesOutcome ListAttachedPolicies(const Model::ListAttachedPoliciesRequest& request) const;
 
        template<typename ListAttachedPoliciesRequestT = Model::ListAttachedPoliciesRequest>
        Model::ListAttachedPoliciesOutcomeCallable ListAttachedPoliciesCallable(const ListAttachedPoliciesRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListAttachedPolicies, request);
        }
 
        template<typename ListAttachedPoliciesRequestT = Model::ListAttachedPoliciesRequest>
        void ListAttachedPoliciesAsync(const ListAttachedPoliciesRequestT& request, const ListAttachedPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListAttachedPolicies, request, handler, context);
        }
 
        virtual Model::ListAuditFindingsOutcome ListAuditFindings(const Model::ListAuditFindingsRequest& request = {}) const;
 
        template<typename ListAuditFindingsRequestT = Model::ListAuditFindingsRequest>
        Model::ListAuditFindingsOutcomeCallable ListAuditFindingsCallable(const ListAuditFindingsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListAuditFindings, request);
        }
 
        template<typename ListAuditFindingsRequestT = Model::ListAuditFindingsRequest>
        void ListAuditFindingsAsync(const ListAuditFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAuditFindingsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListAuditFindings, request, handler, context);
        }
 
        virtual Model::ListAuditMitigationActionsExecutionsOutcome ListAuditMitigationActionsExecutions(const Model::ListAuditMitigationActionsExecutionsRequest& request) const;
 
        template<typename ListAuditMitigationActionsExecutionsRequestT = Model::ListAuditMitigationActionsExecutionsRequest>
        Model::ListAuditMitigationActionsExecutionsOutcomeCallable ListAuditMitigationActionsExecutionsCallable(const ListAuditMitigationActionsExecutionsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListAuditMitigationActionsExecutions, request);
        }
 
        template<typename ListAuditMitigationActionsExecutionsRequestT = Model::ListAuditMitigationActionsExecutionsRequest>
        void ListAuditMitigationActionsExecutionsAsync(const ListAuditMitigationActionsExecutionsRequestT& request, const ListAuditMitigationActionsExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListAuditMitigationActionsExecutions, request, handler, context);
        }
 
        virtual Model::ListAuditMitigationActionsTasksOutcome ListAuditMitigationActionsTasks(const Model::ListAuditMitigationActionsTasksRequest& request) const;
 
        template<typename ListAuditMitigationActionsTasksRequestT = Model::ListAuditMitigationActionsTasksRequest>
        Model::ListAuditMitigationActionsTasksOutcomeCallable ListAuditMitigationActionsTasksCallable(const ListAuditMitigationActionsTasksRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListAuditMitigationActionsTasks, request);
        }
 
        template<typename ListAuditMitigationActionsTasksRequestT = Model::ListAuditMitigationActionsTasksRequest>
        void ListAuditMitigationActionsTasksAsync(const ListAuditMitigationActionsTasksRequestT& request, const ListAuditMitigationActionsTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListAuditMitigationActionsTasks, request, handler, context);
        }
 
        virtual Model::ListAuditSuppressionsOutcome ListAuditSuppressions(const Model::ListAuditSuppressionsRequest& request = {}) const;
 
        template<typename ListAuditSuppressionsRequestT = Model::ListAuditSuppressionsRequest>
        Model::ListAuditSuppressionsOutcomeCallable ListAuditSuppressionsCallable(const ListAuditSuppressionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListAuditSuppressions, request);
        }
 
        template<typename ListAuditSuppressionsRequestT = Model::ListAuditSuppressionsRequest>
        void ListAuditSuppressionsAsync(const ListAuditSuppressionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAuditSuppressionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListAuditSuppressions, request, handler, context);
        }
 
        virtual Model::ListAuditTasksOutcome ListAuditTasks(const Model::ListAuditTasksRequest& request) const;
 
        template<typename ListAuditTasksRequestT = Model::ListAuditTasksRequest>
        Model::ListAuditTasksOutcomeCallable ListAuditTasksCallable(const ListAuditTasksRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListAuditTasks, request);
        }
 
        template<typename ListAuditTasksRequestT = Model::ListAuditTasksRequest>
        void ListAuditTasksAsync(const ListAuditTasksRequestT& request, const ListAuditTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListAuditTasks, request, handler, context);
        }
 
        virtual Model::ListAuthorizersOutcome ListAuthorizers(const Model::ListAuthorizersRequest& request = {}) const;
 
        template<typename ListAuthorizersRequestT = Model::ListAuthorizersRequest>
        Model::ListAuthorizersOutcomeCallable ListAuthorizersCallable(const ListAuthorizersRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListAuthorizers, request);
        }
 
        template<typename ListAuthorizersRequestT = Model::ListAuthorizersRequest>
        void ListAuthorizersAsync(const ListAuthorizersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAuthorizersRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListAuthorizers, request, handler, context);
        }
 
        virtual Model::ListBillingGroupsOutcome ListBillingGroups(const Model::ListBillingGroupsRequest& request = {}) const;
 
        template<typename ListBillingGroupsRequestT = Model::ListBillingGroupsRequest>
        Model::ListBillingGroupsOutcomeCallable ListBillingGroupsCallable(const ListBillingGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListBillingGroups, request);
        }
 
        template<typename ListBillingGroupsRequestT = Model::ListBillingGroupsRequest>
        void ListBillingGroupsAsync(const ListBillingGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBillingGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListBillingGroups, request, handler, context);
        }
 
        virtual Model::ListCACertificatesOutcome ListCACertificates(const Model::ListCACertificatesRequest& request = {}) const;
 
        template<typename ListCACertificatesRequestT = Model::ListCACertificatesRequest>
        Model::ListCACertificatesOutcomeCallable ListCACertificatesCallable(const ListCACertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListCACertificates, request);
        }
 
        template<typename ListCACertificatesRequestT = Model::ListCACertificatesRequest>
        void ListCACertificatesAsync(const ListCACertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCACertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListCACertificates, request, handler, context);
        }
 
        virtual Model::ListCertificateProvidersOutcome ListCertificateProviders(const Model::ListCertificateProvidersRequest& request = {}) const;
 
        template<typename ListCertificateProvidersRequestT = Model::ListCertificateProvidersRequest>
        Model::ListCertificateProvidersOutcomeCallable ListCertificateProvidersCallable(const ListCertificateProvidersRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListCertificateProviders, request);
        }
 
        template<typename ListCertificateProvidersRequestT = Model::ListCertificateProvidersRequest>
        void ListCertificateProvidersAsync(const ListCertificateProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCertificateProvidersRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListCertificateProviders, request, handler, context);
        }
 
        virtual Model::ListCertificatesOutcome ListCertificates(const Model::ListCertificatesRequest& request = {}) const;
 
        template<typename ListCertificatesRequestT = Model::ListCertificatesRequest>
        Model::ListCertificatesOutcomeCallable ListCertificatesCallable(const ListCertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListCertificates, request);
        }
 
        template<typename ListCertificatesRequestT = Model::ListCertificatesRequest>
        void ListCertificatesAsync(const ListCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListCertificates, request, handler, context);
        }
 
        virtual Model::ListCertificatesByCAOutcome ListCertificatesByCA(const Model::ListCertificatesByCARequest& request) const;
 
        template<typename ListCertificatesByCARequestT = Model::ListCertificatesByCARequest>
        Model::ListCertificatesByCAOutcomeCallable ListCertificatesByCACallable(const ListCertificatesByCARequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListCertificatesByCA, request);
        }
 
        template<typename ListCertificatesByCARequestT = Model::ListCertificatesByCARequest>
        void ListCertificatesByCAAsync(const ListCertificatesByCARequestT& request, const ListCertificatesByCAResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListCertificatesByCA, request, handler, context);
        }
 
        virtual Model::ListCommandExecutionsOutcome ListCommandExecutions(const Model::ListCommandExecutionsRequest& request = {}) const;
 
        template<typename ListCommandExecutionsRequestT = Model::ListCommandExecutionsRequest>
        Model::ListCommandExecutionsOutcomeCallable ListCommandExecutionsCallable(const ListCommandExecutionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListCommandExecutions, request);
        }
 
        template<typename ListCommandExecutionsRequestT = Model::ListCommandExecutionsRequest>
        void ListCommandExecutionsAsync(const ListCommandExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCommandExecutionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListCommandExecutions, request, handler, context);
        }
 
        virtual Model::ListCommandsOutcome ListCommands(const Model::ListCommandsRequest& request = {}) const;
 
        template<typename ListCommandsRequestT = Model::ListCommandsRequest>
        Model::ListCommandsOutcomeCallable ListCommandsCallable(const ListCommandsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListCommands, request);
        }
 
        template<typename ListCommandsRequestT = Model::ListCommandsRequest>
        void ListCommandsAsync(const ListCommandsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCommandsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListCommands, request, handler, context);
        }
 
        virtual Model::ListCustomMetricsOutcome ListCustomMetrics(const Model::ListCustomMetricsRequest& request = {}) const;
 
        template<typename ListCustomMetricsRequestT = Model::ListCustomMetricsRequest>
        Model::ListCustomMetricsOutcomeCallable ListCustomMetricsCallable(const ListCustomMetricsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListCustomMetrics, request);
        }
 
        template<typename ListCustomMetricsRequestT = Model::ListCustomMetricsRequest>
        void ListCustomMetricsAsync(const ListCustomMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomMetricsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListCustomMetrics, request, handler, context);
        }
 
        virtual Model::ListDetectMitigationActionsExecutionsOutcome ListDetectMitigationActionsExecutions(const Model::ListDetectMitigationActionsExecutionsRequest& request = {}) const;
 
        template<typename ListDetectMitigationActionsExecutionsRequestT = Model::ListDetectMitigationActionsExecutionsRequest>
        Model::ListDetectMitigationActionsExecutionsOutcomeCallable ListDetectMitigationActionsExecutionsCallable(const ListDetectMitigationActionsExecutionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListDetectMitigationActionsExecutions, request);
        }
 
        template<typename ListDetectMitigationActionsExecutionsRequestT = Model::ListDetectMitigationActionsExecutionsRequest>
        void ListDetectMitigationActionsExecutionsAsync(const ListDetectMitigationActionsExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDetectMitigationActionsExecutionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListDetectMitigationActionsExecutions, request, handler, context);
        }
 
        virtual Model::ListDetectMitigationActionsTasksOutcome ListDetectMitigationActionsTasks(const Model::ListDetectMitigationActionsTasksRequest& request) const;
 
        template<typename ListDetectMitigationActionsTasksRequestT = Model::ListDetectMitigationActionsTasksRequest>
        Model::ListDetectMitigationActionsTasksOutcomeCallable ListDetectMitigationActionsTasksCallable(const ListDetectMitigationActionsTasksRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListDetectMitigationActionsTasks, request);
        }
 
        template<typename ListDetectMitigationActionsTasksRequestT = Model::ListDetectMitigationActionsTasksRequest>
        void ListDetectMitigationActionsTasksAsync(const ListDetectMitigationActionsTasksRequestT& request, const ListDetectMitigationActionsTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListDetectMitigationActionsTasks, request, handler, context);
        }
 
        virtual Model::ListDimensionsOutcome ListDimensions(const Model::ListDimensionsRequest& request = {}) const;
 
        template<typename ListDimensionsRequestT = Model::ListDimensionsRequest>
        Model::ListDimensionsOutcomeCallable ListDimensionsCallable(const ListDimensionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListDimensions, request);
        }
 
        template<typename ListDimensionsRequestT = Model::ListDimensionsRequest>
        void ListDimensionsAsync(const ListDimensionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDimensionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListDimensions, request, handler, context);
        }
 
        virtual Model::ListDomainConfigurationsOutcome ListDomainConfigurations(const Model::ListDomainConfigurationsRequest& request = {}) const;
 
        template<typename ListDomainConfigurationsRequestT = Model::ListDomainConfigurationsRequest>
        Model::ListDomainConfigurationsOutcomeCallable ListDomainConfigurationsCallable(const ListDomainConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListDomainConfigurations, request);
        }
 
        template<typename ListDomainConfigurationsRequestT = Model::ListDomainConfigurationsRequest>
        void ListDomainConfigurationsAsync(const ListDomainConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDomainConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListDomainConfigurations, request, handler, context);
        }
 
        virtual Model::ListFleetMetricsOutcome ListFleetMetrics(const Model::ListFleetMetricsRequest& request = {}) const;
 
        template<typename ListFleetMetricsRequestT = Model::ListFleetMetricsRequest>
        Model::ListFleetMetricsOutcomeCallable ListFleetMetricsCallable(const ListFleetMetricsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListFleetMetrics, request);
        }
 
        template<typename ListFleetMetricsRequestT = Model::ListFleetMetricsRequest>
        void ListFleetMetricsAsync(const ListFleetMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFleetMetricsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListFleetMetrics, request, handler, context);
        }
 
        virtual Model::ListIndicesOutcome ListIndices(const Model::ListIndicesRequest& request = {}) const;
 
        template<typename ListIndicesRequestT = Model::ListIndicesRequest>
        Model::ListIndicesOutcomeCallable ListIndicesCallable(const ListIndicesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListIndices, request);
        }
 
        template<typename ListIndicesRequestT = Model::ListIndicesRequest>
        void ListIndicesAsync(const ListIndicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIndicesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListIndices, request, handler, context);
        }
 
        virtual Model::ListJobExecutionsForJobOutcome ListJobExecutionsForJob(const Model::ListJobExecutionsForJobRequest& request) const;
 
        template<typename ListJobExecutionsForJobRequestT = Model::ListJobExecutionsForJobRequest>
        Model::ListJobExecutionsForJobOutcomeCallable ListJobExecutionsForJobCallable(const ListJobExecutionsForJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListJobExecutionsForJob, request);
        }
 
        template<typename ListJobExecutionsForJobRequestT = Model::ListJobExecutionsForJobRequest>
        void ListJobExecutionsForJobAsync(const ListJobExecutionsForJobRequestT& request, const ListJobExecutionsForJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListJobExecutionsForJob, request, handler, context);
        }
 
        virtual Model::ListJobExecutionsForThingOutcome ListJobExecutionsForThing(const Model::ListJobExecutionsForThingRequest& request) const;
 
        template<typename ListJobExecutionsForThingRequestT = Model::ListJobExecutionsForThingRequest>
        Model::ListJobExecutionsForThingOutcomeCallable ListJobExecutionsForThingCallable(const ListJobExecutionsForThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListJobExecutionsForThing, request);
        }
 
        template<typename ListJobExecutionsForThingRequestT = Model::ListJobExecutionsForThingRequest>
        void ListJobExecutionsForThingAsync(const ListJobExecutionsForThingRequestT& request, const ListJobExecutionsForThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListJobExecutionsForThing, request, handler, context);
        }
 
        virtual Model::ListJobTemplatesOutcome ListJobTemplates(const Model::ListJobTemplatesRequest& request = {}) const;
 
        template<typename ListJobTemplatesRequestT = Model::ListJobTemplatesRequest>
        Model::ListJobTemplatesOutcomeCallable ListJobTemplatesCallable(const ListJobTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListJobTemplates, request);
        }
 
        template<typename ListJobTemplatesRequestT = Model::ListJobTemplatesRequest>
        void ListJobTemplatesAsync(const ListJobTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJobTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListJobTemplates, request, handler, context);
        }
 
        virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request = {}) const;
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListJobs, request);
        }
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        void ListJobsAsync(const ListJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJobsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListJobs, request, handler, context);
        }
 
        virtual Model::ListManagedJobTemplatesOutcome ListManagedJobTemplates(const Model::ListManagedJobTemplatesRequest& request = {}) const;
 
        template<typename ListManagedJobTemplatesRequestT = Model::ListManagedJobTemplatesRequest>
        Model::ListManagedJobTemplatesOutcomeCallable ListManagedJobTemplatesCallable(const ListManagedJobTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListManagedJobTemplates, request);
        }
 
        template<typename ListManagedJobTemplatesRequestT = Model::ListManagedJobTemplatesRequest>
        void ListManagedJobTemplatesAsync(const ListManagedJobTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListManagedJobTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListManagedJobTemplates, request, handler, context);
        }
 
        virtual Model::ListMetricValuesOutcome ListMetricValues(const Model::ListMetricValuesRequest& request) const;
 
        template<typename ListMetricValuesRequestT = Model::ListMetricValuesRequest>
        Model::ListMetricValuesOutcomeCallable ListMetricValuesCallable(const ListMetricValuesRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListMetricValues, request);
        }
 
        template<typename ListMetricValuesRequestT = Model::ListMetricValuesRequest>
        void ListMetricValuesAsync(const ListMetricValuesRequestT& request, const ListMetricValuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListMetricValues, request, handler, context);
        }
 
        virtual Model::ListMitigationActionsOutcome ListMitigationActions(const Model::ListMitigationActionsRequest& request = {}) const;
 
        template<typename ListMitigationActionsRequestT = Model::ListMitigationActionsRequest>
        Model::ListMitigationActionsOutcomeCallable ListMitigationActionsCallable(const ListMitigationActionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListMitigationActions, request);
        }
 
        template<typename ListMitigationActionsRequestT = Model::ListMitigationActionsRequest>
        void ListMitigationActionsAsync(const ListMitigationActionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMitigationActionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListMitigationActions, request, handler, context);
        }
 
        virtual Model::ListOTAUpdatesOutcome ListOTAUpdates(const Model::ListOTAUpdatesRequest& request = {}) const;
 
        template<typename ListOTAUpdatesRequestT = Model::ListOTAUpdatesRequest>
        Model::ListOTAUpdatesOutcomeCallable ListOTAUpdatesCallable(const ListOTAUpdatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListOTAUpdates, request);
        }
 
        template<typename ListOTAUpdatesRequestT = Model::ListOTAUpdatesRequest>
        void ListOTAUpdatesAsync(const ListOTAUpdatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOTAUpdatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListOTAUpdates, request, handler, context);
        }
 
        virtual Model::ListOutgoingCertificatesOutcome ListOutgoingCertificates(const Model::ListOutgoingCertificatesRequest& request = {}) const;
 
        template<typename ListOutgoingCertificatesRequestT = Model::ListOutgoingCertificatesRequest>
        Model::ListOutgoingCertificatesOutcomeCallable ListOutgoingCertificatesCallable(const ListOutgoingCertificatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListOutgoingCertificates, request);
        }
 
        template<typename ListOutgoingCertificatesRequestT = Model::ListOutgoingCertificatesRequest>
        void ListOutgoingCertificatesAsync(const ListOutgoingCertificatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOutgoingCertificatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListOutgoingCertificates, request, handler, context);
        }
 
        virtual Model::ListPackageVersionsOutcome ListPackageVersions(const Model::ListPackageVersionsRequest& request) const;
 
        template<typename ListPackageVersionsRequestT = Model::ListPackageVersionsRequest>
        Model::ListPackageVersionsOutcomeCallable ListPackageVersionsCallable(const ListPackageVersionsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListPackageVersions, request);
        }
 
        template<typename ListPackageVersionsRequestT = Model::ListPackageVersionsRequest>
        void ListPackageVersionsAsync(const ListPackageVersionsRequestT& request, const ListPackageVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListPackageVersions, request, handler, context);
        }
 
        virtual Model::ListPackagesOutcome ListPackages(const Model::ListPackagesRequest& request = {}) const;
 
        template<typename ListPackagesRequestT = Model::ListPackagesRequest>
        Model::ListPackagesOutcomeCallable ListPackagesCallable(const ListPackagesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListPackages, request);
        }
 
        template<typename ListPackagesRequestT = Model::ListPackagesRequest>
        void ListPackagesAsync(const ListPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPackagesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListPackages, request, handler, context);
        }
 
        virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request = {}) const;
 
        template<typename ListPoliciesRequestT = Model::ListPoliciesRequest>
        Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListPolicies, request);
        }
 
        template<typename ListPoliciesRequestT = Model::ListPoliciesRequest>
        void ListPoliciesAsync(const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListPolicies, request, handler, context);
        }
 
        virtual Model::ListPolicyVersionsOutcome ListPolicyVersions(const Model::ListPolicyVersionsRequest& request) const;
 
        template<typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
        Model::ListPolicyVersionsOutcomeCallable ListPolicyVersionsCallable(const ListPolicyVersionsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListPolicyVersions, request);
        }
 
        template<typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
        void ListPolicyVersionsAsync(const ListPolicyVersionsRequestT& request, const ListPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListPolicyVersions, request, handler, context);
        }
 
        virtual Model::ListPrincipalThingsOutcome ListPrincipalThings(const Model::ListPrincipalThingsRequest& request) const;
 
        template<typename ListPrincipalThingsRequestT = Model::ListPrincipalThingsRequest>
        Model::ListPrincipalThingsOutcomeCallable ListPrincipalThingsCallable(const ListPrincipalThingsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListPrincipalThings, request);
        }
 
        template<typename ListPrincipalThingsRequestT = Model::ListPrincipalThingsRequest>
        void ListPrincipalThingsAsync(const ListPrincipalThingsRequestT& request, const ListPrincipalThingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListPrincipalThings, request, handler, context);
        }
 
        virtual Model::ListPrincipalThingsV2Outcome ListPrincipalThingsV2(const Model::ListPrincipalThingsV2Request& request) const;
 
        template<typename ListPrincipalThingsV2RequestT = Model::ListPrincipalThingsV2Request>
        Model::ListPrincipalThingsV2OutcomeCallable ListPrincipalThingsV2Callable(const ListPrincipalThingsV2RequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListPrincipalThingsV2, request);
        }
 
        template<typename ListPrincipalThingsV2RequestT = Model::ListPrincipalThingsV2Request>
        void ListPrincipalThingsV2Async(const ListPrincipalThingsV2RequestT& request, const ListPrincipalThingsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListPrincipalThingsV2, request, handler, context);
        }
 
        virtual Model::ListProvisioningTemplateVersionsOutcome ListProvisioningTemplateVersions(const Model::ListProvisioningTemplateVersionsRequest& request) const;
 
        template<typename ListProvisioningTemplateVersionsRequestT = Model::ListProvisioningTemplateVersionsRequest>
        Model::ListProvisioningTemplateVersionsOutcomeCallable ListProvisioningTemplateVersionsCallable(const ListProvisioningTemplateVersionsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListProvisioningTemplateVersions, request);
        }
 
        template<typename ListProvisioningTemplateVersionsRequestT = Model::ListProvisioningTemplateVersionsRequest>
        void ListProvisioningTemplateVersionsAsync(const ListProvisioningTemplateVersionsRequestT& request, const ListProvisioningTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListProvisioningTemplateVersions, request, handler, context);
        }
 
        virtual Model::ListProvisioningTemplatesOutcome ListProvisioningTemplates(const Model::ListProvisioningTemplatesRequest& request = {}) const;
 
        template<typename ListProvisioningTemplatesRequestT = Model::ListProvisioningTemplatesRequest>
        Model::ListProvisioningTemplatesOutcomeCallable ListProvisioningTemplatesCallable(const ListProvisioningTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListProvisioningTemplates, request);
        }
 
        template<typename ListProvisioningTemplatesRequestT = Model::ListProvisioningTemplatesRequest>
        void ListProvisioningTemplatesAsync(const ListProvisioningTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProvisioningTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListProvisioningTemplates, request, handler, context);
        }
 
        virtual Model::ListRelatedResourcesForAuditFindingOutcome ListRelatedResourcesForAuditFinding(const Model::ListRelatedResourcesForAuditFindingRequest& request) const;
 
        template<typename ListRelatedResourcesForAuditFindingRequestT = Model::ListRelatedResourcesForAuditFindingRequest>
        Model::ListRelatedResourcesForAuditFindingOutcomeCallable ListRelatedResourcesForAuditFindingCallable(const ListRelatedResourcesForAuditFindingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListRelatedResourcesForAuditFinding, request);
        }
 
        template<typename ListRelatedResourcesForAuditFindingRequestT = Model::ListRelatedResourcesForAuditFindingRequest>
        void ListRelatedResourcesForAuditFindingAsync(const ListRelatedResourcesForAuditFindingRequestT& request, const ListRelatedResourcesForAuditFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListRelatedResourcesForAuditFinding, request, handler, context);
        }
 
        virtual Model::ListRoleAliasesOutcome ListRoleAliases(const Model::ListRoleAliasesRequest& request = {}) const;
 
        template<typename ListRoleAliasesRequestT = Model::ListRoleAliasesRequest>
        Model::ListRoleAliasesOutcomeCallable ListRoleAliasesCallable(const ListRoleAliasesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListRoleAliases, request);
        }
 
        template<typename ListRoleAliasesRequestT = Model::ListRoleAliasesRequest>
        void ListRoleAliasesAsync(const ListRoleAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRoleAliasesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListRoleAliases, request, handler, context);
        }
 
        virtual Model::ListSbomValidationResultsOutcome ListSbomValidationResults(const Model::ListSbomValidationResultsRequest& request) const;
 
        template<typename ListSbomValidationResultsRequestT = Model::ListSbomValidationResultsRequest>
        Model::ListSbomValidationResultsOutcomeCallable ListSbomValidationResultsCallable(const ListSbomValidationResultsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListSbomValidationResults, request);
        }
 
        template<typename ListSbomValidationResultsRequestT = Model::ListSbomValidationResultsRequest>
        void ListSbomValidationResultsAsync(const ListSbomValidationResultsRequestT& request, const ListSbomValidationResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListSbomValidationResults, request, handler, context);
        }
 
        virtual Model::ListScheduledAuditsOutcome ListScheduledAudits(const Model::ListScheduledAuditsRequest& request = {}) const;
 
        template<typename ListScheduledAuditsRequestT = Model::ListScheduledAuditsRequest>
        Model::ListScheduledAuditsOutcomeCallable ListScheduledAuditsCallable(const ListScheduledAuditsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListScheduledAudits, request);
        }
 
        template<typename ListScheduledAuditsRequestT = Model::ListScheduledAuditsRequest>
        void ListScheduledAuditsAsync(const ListScheduledAuditsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListScheduledAuditsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListScheduledAudits, request, handler, context);
        }
 
        virtual Model::ListSecurityProfilesOutcome ListSecurityProfiles(const Model::ListSecurityProfilesRequest& request = {}) const;
 
        template<typename ListSecurityProfilesRequestT = Model::ListSecurityProfilesRequest>
        Model::ListSecurityProfilesOutcomeCallable ListSecurityProfilesCallable(const ListSecurityProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListSecurityProfiles, request);
        }
 
        template<typename ListSecurityProfilesRequestT = Model::ListSecurityProfilesRequest>
        void ListSecurityProfilesAsync(const ListSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSecurityProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListSecurityProfiles, request, handler, context);
        }
 
        virtual Model::ListSecurityProfilesForTargetOutcome ListSecurityProfilesForTarget(const Model::ListSecurityProfilesForTargetRequest& request) const;
 
        template<typename ListSecurityProfilesForTargetRequestT = Model::ListSecurityProfilesForTargetRequest>
        Model::ListSecurityProfilesForTargetOutcomeCallable ListSecurityProfilesForTargetCallable(const ListSecurityProfilesForTargetRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListSecurityProfilesForTarget, request);
        }
 
        template<typename ListSecurityProfilesForTargetRequestT = Model::ListSecurityProfilesForTargetRequest>
        void ListSecurityProfilesForTargetAsync(const ListSecurityProfilesForTargetRequestT& request, const ListSecurityProfilesForTargetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListSecurityProfilesForTarget, request, handler, context);
        }
 
        virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request = {}) const;
 
        template<typename ListStreamsRequestT = Model::ListStreamsRequest>
        Model::ListStreamsOutcomeCallable ListStreamsCallable(const ListStreamsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListStreams, request);
        }
 
        template<typename ListStreamsRequestT = Model::ListStreamsRequest>
        void ListStreamsAsync(const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListStreamsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListStreams, 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(&IoTClient::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(&IoTClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTargetsForPolicyOutcome ListTargetsForPolicy(const Model::ListTargetsForPolicyRequest& request) const;
 
        template<typename ListTargetsForPolicyRequestT = Model::ListTargetsForPolicyRequest>
        Model::ListTargetsForPolicyOutcomeCallable ListTargetsForPolicyCallable(const ListTargetsForPolicyRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListTargetsForPolicy, request);
        }
 
        template<typename ListTargetsForPolicyRequestT = Model::ListTargetsForPolicyRequest>
        void ListTargetsForPolicyAsync(const ListTargetsForPolicyRequestT& request, const ListTargetsForPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListTargetsForPolicy, request, handler, context);
        }
 
        virtual Model::ListTargetsForSecurityProfileOutcome ListTargetsForSecurityProfile(const Model::ListTargetsForSecurityProfileRequest& request) const;
 
        template<typename ListTargetsForSecurityProfileRequestT = Model::ListTargetsForSecurityProfileRequest>
        Model::ListTargetsForSecurityProfileOutcomeCallable ListTargetsForSecurityProfileCallable(const ListTargetsForSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListTargetsForSecurityProfile, request);
        }
 
        template<typename ListTargetsForSecurityProfileRequestT = Model::ListTargetsForSecurityProfileRequest>
        void ListTargetsForSecurityProfileAsync(const ListTargetsForSecurityProfileRequestT& request, const ListTargetsForSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListTargetsForSecurityProfile, request, handler, context);
        }
 
        virtual Model::ListThingGroupsOutcome ListThingGroups(const Model::ListThingGroupsRequest& request = {}) const;
 
        template<typename ListThingGroupsRequestT = Model::ListThingGroupsRequest>
        Model::ListThingGroupsOutcomeCallable ListThingGroupsCallable(const ListThingGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListThingGroups, request);
        }
 
        template<typename ListThingGroupsRequestT = Model::ListThingGroupsRequest>
        void ListThingGroupsAsync(const ListThingGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListThingGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListThingGroups, request, handler, context);
        }
 
        virtual Model::ListThingGroupsForThingOutcome ListThingGroupsForThing(const Model::ListThingGroupsForThingRequest& request) const;
 
        template<typename ListThingGroupsForThingRequestT = Model::ListThingGroupsForThingRequest>
        Model::ListThingGroupsForThingOutcomeCallable ListThingGroupsForThingCallable(const ListThingGroupsForThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListThingGroupsForThing, request);
        }
 
        template<typename ListThingGroupsForThingRequestT = Model::ListThingGroupsForThingRequest>
        void ListThingGroupsForThingAsync(const ListThingGroupsForThingRequestT& request, const ListThingGroupsForThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListThingGroupsForThing, request, handler, context);
        }
 
        virtual Model::ListThingPrincipalsOutcome ListThingPrincipals(const Model::ListThingPrincipalsRequest& request) const;
 
        template<typename ListThingPrincipalsRequestT = Model::ListThingPrincipalsRequest>
        Model::ListThingPrincipalsOutcomeCallable ListThingPrincipalsCallable(const ListThingPrincipalsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListThingPrincipals, request);
        }
 
        template<typename ListThingPrincipalsRequestT = Model::ListThingPrincipalsRequest>
        void ListThingPrincipalsAsync(const ListThingPrincipalsRequestT& request, const ListThingPrincipalsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListThingPrincipals, request, handler, context);
        }
 
        virtual Model::ListThingPrincipalsV2Outcome ListThingPrincipalsV2(const Model::ListThingPrincipalsV2Request& request) const;
 
        template<typename ListThingPrincipalsV2RequestT = Model::ListThingPrincipalsV2Request>
        Model::ListThingPrincipalsV2OutcomeCallable ListThingPrincipalsV2Callable(const ListThingPrincipalsV2RequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListThingPrincipalsV2, request);
        }
 
        template<typename ListThingPrincipalsV2RequestT = Model::ListThingPrincipalsV2Request>
        void ListThingPrincipalsV2Async(const ListThingPrincipalsV2RequestT& request, const ListThingPrincipalsV2ResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListThingPrincipalsV2, request, handler, context);
        }
 
        virtual Model::ListThingRegistrationTaskReportsOutcome ListThingRegistrationTaskReports(const Model::ListThingRegistrationTaskReportsRequest& request) const;
 
        template<typename ListThingRegistrationTaskReportsRequestT = Model::ListThingRegistrationTaskReportsRequest>
        Model::ListThingRegistrationTaskReportsOutcomeCallable ListThingRegistrationTaskReportsCallable(const ListThingRegistrationTaskReportsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListThingRegistrationTaskReports, request);
        }
 
        template<typename ListThingRegistrationTaskReportsRequestT = Model::ListThingRegistrationTaskReportsRequest>
        void ListThingRegistrationTaskReportsAsync(const ListThingRegistrationTaskReportsRequestT& request, const ListThingRegistrationTaskReportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListThingRegistrationTaskReports, request, handler, context);
        }
 
        virtual Model::ListThingRegistrationTasksOutcome ListThingRegistrationTasks(const Model::ListThingRegistrationTasksRequest& request = {}) const;
 
        template<typename ListThingRegistrationTasksRequestT = Model::ListThingRegistrationTasksRequest>
        Model::ListThingRegistrationTasksOutcomeCallable ListThingRegistrationTasksCallable(const ListThingRegistrationTasksRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListThingRegistrationTasks, request);
        }
 
        template<typename ListThingRegistrationTasksRequestT = Model::ListThingRegistrationTasksRequest>
        void ListThingRegistrationTasksAsync(const ListThingRegistrationTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListThingRegistrationTasksRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListThingRegistrationTasks, request, handler, context);
        }
 
        virtual Model::ListThingTypesOutcome ListThingTypes(const Model::ListThingTypesRequest& request = {}) const;
 
        template<typename ListThingTypesRequestT = Model::ListThingTypesRequest>
        Model::ListThingTypesOutcomeCallable ListThingTypesCallable(const ListThingTypesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListThingTypes, request);
        }
 
        template<typename ListThingTypesRequestT = Model::ListThingTypesRequest>
        void ListThingTypesAsync(const ListThingTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListThingTypesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListThingTypes, request, handler, context);
        }
 
        virtual Model::ListThingsOutcome ListThings(const Model::ListThingsRequest& request = {}) const;
 
        template<typename ListThingsRequestT = Model::ListThingsRequest>
        Model::ListThingsOutcomeCallable ListThingsCallable(const ListThingsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListThings, request);
        }
 
        template<typename ListThingsRequestT = Model::ListThingsRequest>
        void ListThingsAsync(const ListThingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListThingsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListThings, request, handler, context);
        }
 
        virtual Model::ListThingsInBillingGroupOutcome ListThingsInBillingGroup(const Model::ListThingsInBillingGroupRequest& request) const;
 
        template<typename ListThingsInBillingGroupRequestT = Model::ListThingsInBillingGroupRequest>
        Model::ListThingsInBillingGroupOutcomeCallable ListThingsInBillingGroupCallable(const ListThingsInBillingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListThingsInBillingGroup, request);
        }
 
        template<typename ListThingsInBillingGroupRequestT = Model::ListThingsInBillingGroupRequest>
        void ListThingsInBillingGroupAsync(const ListThingsInBillingGroupRequestT& request, const ListThingsInBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListThingsInBillingGroup, request, handler, context);
        }
 
        virtual Model::ListThingsInThingGroupOutcome ListThingsInThingGroup(const Model::ListThingsInThingGroupRequest& request) const;
 
        template<typename ListThingsInThingGroupRequestT = Model::ListThingsInThingGroupRequest>
        Model::ListThingsInThingGroupOutcomeCallable ListThingsInThingGroupCallable(const ListThingsInThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListThingsInThingGroup, request);
        }
 
        template<typename ListThingsInThingGroupRequestT = Model::ListThingsInThingGroupRequest>
        void ListThingsInThingGroupAsync(const ListThingsInThingGroupRequestT& request, const ListThingsInThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListThingsInThingGroup, request, handler, context);
        }
 
        virtual Model::ListTopicRuleDestinationsOutcome ListTopicRuleDestinations(const Model::ListTopicRuleDestinationsRequest& request = {}) const;
 
        template<typename ListTopicRuleDestinationsRequestT = Model::ListTopicRuleDestinationsRequest>
        Model::ListTopicRuleDestinationsOutcomeCallable ListTopicRuleDestinationsCallable(const ListTopicRuleDestinationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListTopicRuleDestinations, request);
        }
 
        template<typename ListTopicRuleDestinationsRequestT = Model::ListTopicRuleDestinationsRequest>
        void ListTopicRuleDestinationsAsync(const ListTopicRuleDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTopicRuleDestinationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListTopicRuleDestinations, request, handler, context);
        }
 
        virtual Model::ListTopicRulesOutcome ListTopicRules(const Model::ListTopicRulesRequest& request = {}) const;
 
        template<typename ListTopicRulesRequestT = Model::ListTopicRulesRequest>
        Model::ListTopicRulesOutcomeCallable ListTopicRulesCallable(const ListTopicRulesRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListTopicRules, request);
        }
 
        template<typename ListTopicRulesRequestT = Model::ListTopicRulesRequest>
        void ListTopicRulesAsync(const ListTopicRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTopicRulesRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListTopicRules, request, handler, context);
        }
 
        virtual Model::ListV2LoggingLevelsOutcome ListV2LoggingLevels(const Model::ListV2LoggingLevelsRequest& request = {}) const;
 
        template<typename ListV2LoggingLevelsRequestT = Model::ListV2LoggingLevelsRequest>
        Model::ListV2LoggingLevelsOutcomeCallable ListV2LoggingLevelsCallable(const ListV2LoggingLevelsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::ListV2LoggingLevels, request);
        }
 
        template<typename ListV2LoggingLevelsRequestT = Model::ListV2LoggingLevelsRequest>
        void ListV2LoggingLevelsAsync(const ListV2LoggingLevelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListV2LoggingLevelsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::ListV2LoggingLevels, request, handler, context);
        }
 
        virtual Model::ListViolationEventsOutcome ListViolationEvents(const Model::ListViolationEventsRequest& request) const;
 
        template<typename ListViolationEventsRequestT = Model::ListViolationEventsRequest>
        Model::ListViolationEventsOutcomeCallable ListViolationEventsCallable(const ListViolationEventsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ListViolationEvents, request);
        }
 
        template<typename ListViolationEventsRequestT = Model::ListViolationEventsRequest>
        void ListViolationEventsAsync(const ListViolationEventsRequestT& request, const ListViolationEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ListViolationEvents, request, handler, context);
        }
 
        virtual Model::PutVerificationStateOnViolationOutcome PutVerificationStateOnViolation(const Model::PutVerificationStateOnViolationRequest& request) const;
 
        template<typename PutVerificationStateOnViolationRequestT = Model::PutVerificationStateOnViolationRequest>
        Model::PutVerificationStateOnViolationOutcomeCallable PutVerificationStateOnViolationCallable(const PutVerificationStateOnViolationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::PutVerificationStateOnViolation, request);
        }
 
        template<typename PutVerificationStateOnViolationRequestT = Model::PutVerificationStateOnViolationRequest>
        void PutVerificationStateOnViolationAsync(const PutVerificationStateOnViolationRequestT& request, const PutVerificationStateOnViolationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::PutVerificationStateOnViolation, request, handler, context);
        }
 
        virtual Model::RegisterCACertificateOutcome RegisterCACertificate(const Model::RegisterCACertificateRequest& request) const;
 
        template<typename RegisterCACertificateRequestT = Model::RegisterCACertificateRequest>
        Model::RegisterCACertificateOutcomeCallable RegisterCACertificateCallable(const RegisterCACertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::RegisterCACertificate, request);
        }
 
        template<typename RegisterCACertificateRequestT = Model::RegisterCACertificateRequest>
        void RegisterCACertificateAsync(const RegisterCACertificateRequestT& request, const RegisterCACertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::RegisterCACertificate, request, handler, context);
        }
 
        virtual Model::RegisterCertificateOutcome RegisterCertificate(const Model::RegisterCertificateRequest& request) const;
 
        template<typename RegisterCertificateRequestT = Model::RegisterCertificateRequest>
        Model::RegisterCertificateOutcomeCallable RegisterCertificateCallable(const RegisterCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::RegisterCertificate, request);
        }
 
        template<typename RegisterCertificateRequestT = Model::RegisterCertificateRequest>
        void RegisterCertificateAsync(const RegisterCertificateRequestT& request, const RegisterCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::RegisterCertificate, request, handler, context);
        }
 
        virtual Model::RegisterCertificateWithoutCAOutcome RegisterCertificateWithoutCA(const Model::RegisterCertificateWithoutCARequest& request) const;
 
        template<typename RegisterCertificateWithoutCARequestT = Model::RegisterCertificateWithoutCARequest>
        Model::RegisterCertificateWithoutCAOutcomeCallable RegisterCertificateWithoutCACallable(const RegisterCertificateWithoutCARequestT& request) const
        {
            return SubmitCallable(&IoTClient::RegisterCertificateWithoutCA, request);
        }
 
        template<typename RegisterCertificateWithoutCARequestT = Model::RegisterCertificateWithoutCARequest>
        void RegisterCertificateWithoutCAAsync(const RegisterCertificateWithoutCARequestT& request, const RegisterCertificateWithoutCAResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::RegisterCertificateWithoutCA, request, handler, context);
        }
 
        virtual Model::RegisterThingOutcome RegisterThing(const Model::RegisterThingRequest& request) const;
 
        template<typename RegisterThingRequestT = Model::RegisterThingRequest>
        Model::RegisterThingOutcomeCallable RegisterThingCallable(const RegisterThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::RegisterThing, request);
        }
 
        template<typename RegisterThingRequestT = Model::RegisterThingRequest>
        void RegisterThingAsync(const RegisterThingRequestT& request, const RegisterThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::RegisterThing, request, handler, context);
        }
 
        virtual Model::RejectCertificateTransferOutcome RejectCertificateTransfer(const Model::RejectCertificateTransferRequest& request) const;
 
        template<typename RejectCertificateTransferRequestT = Model::RejectCertificateTransferRequest>
        Model::RejectCertificateTransferOutcomeCallable RejectCertificateTransferCallable(const RejectCertificateTransferRequestT& request) const
        {
            return SubmitCallable(&IoTClient::RejectCertificateTransfer, request);
        }
 
        template<typename RejectCertificateTransferRequestT = Model::RejectCertificateTransferRequest>
        void RejectCertificateTransferAsync(const RejectCertificateTransferRequestT& request, const RejectCertificateTransferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::RejectCertificateTransfer, request, handler, context);
        }
 
        virtual Model::RemoveThingFromBillingGroupOutcome RemoveThingFromBillingGroup(const Model::RemoveThingFromBillingGroupRequest& request = {}) const;
 
        template<typename RemoveThingFromBillingGroupRequestT = Model::RemoveThingFromBillingGroupRequest>
        Model::RemoveThingFromBillingGroupOutcomeCallable RemoveThingFromBillingGroupCallable(const RemoveThingFromBillingGroupRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::RemoveThingFromBillingGroup, request);
        }
 
        template<typename RemoveThingFromBillingGroupRequestT = Model::RemoveThingFromBillingGroupRequest>
        void RemoveThingFromBillingGroupAsync(const RemoveThingFromBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RemoveThingFromBillingGroupRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::RemoveThingFromBillingGroup, request, handler, context);
        }
 
        virtual Model::RemoveThingFromThingGroupOutcome RemoveThingFromThingGroup(const Model::RemoveThingFromThingGroupRequest& request = {}) const;
 
        template<typename RemoveThingFromThingGroupRequestT = Model::RemoveThingFromThingGroupRequest>
        Model::RemoveThingFromThingGroupOutcomeCallable RemoveThingFromThingGroupCallable(const RemoveThingFromThingGroupRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::RemoveThingFromThingGroup, request);
        }
 
        template<typename RemoveThingFromThingGroupRequestT = Model::RemoveThingFromThingGroupRequest>
        void RemoveThingFromThingGroupAsync(const RemoveThingFromThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RemoveThingFromThingGroupRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::RemoveThingFromThingGroup, request, handler, context);
        }
 
        virtual Model::ReplaceTopicRuleOutcome ReplaceTopicRule(const Model::ReplaceTopicRuleRequest& request) const;
 
        template<typename ReplaceTopicRuleRequestT = Model::ReplaceTopicRuleRequest>
        Model::ReplaceTopicRuleOutcomeCallable ReplaceTopicRuleCallable(const ReplaceTopicRuleRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ReplaceTopicRule, request);
        }
 
        template<typename ReplaceTopicRuleRequestT = Model::ReplaceTopicRuleRequest>
        void ReplaceTopicRuleAsync(const ReplaceTopicRuleRequestT& request, const ReplaceTopicRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ReplaceTopicRule, request, handler, context);
        }
 
        virtual Model::SearchIndexOutcome SearchIndex(const Model::SearchIndexRequest& request) const;
 
        template<typename SearchIndexRequestT = Model::SearchIndexRequest>
        Model::SearchIndexOutcomeCallable SearchIndexCallable(const SearchIndexRequestT& request) const
        {
            return SubmitCallable(&IoTClient::SearchIndex, request);
        }
 
        template<typename SearchIndexRequestT = Model::SearchIndexRequest>
        void SearchIndexAsync(const SearchIndexRequestT& request, const SearchIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::SearchIndex, request, handler, context);
        }
 
        virtual Model::SetDefaultAuthorizerOutcome SetDefaultAuthorizer(const Model::SetDefaultAuthorizerRequest& request) const;
 
        template<typename SetDefaultAuthorizerRequestT = Model::SetDefaultAuthorizerRequest>
        Model::SetDefaultAuthorizerOutcomeCallable SetDefaultAuthorizerCallable(const SetDefaultAuthorizerRequestT& request) const
        {
            return SubmitCallable(&IoTClient::SetDefaultAuthorizer, request);
        }
 
        template<typename SetDefaultAuthorizerRequestT = Model::SetDefaultAuthorizerRequest>
        void SetDefaultAuthorizerAsync(const SetDefaultAuthorizerRequestT& request, const SetDefaultAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::SetDefaultAuthorizer, request, handler, context);
        }
 
        virtual Model::SetDefaultPolicyVersionOutcome SetDefaultPolicyVersion(const Model::SetDefaultPolicyVersionRequest& request) const;
 
        template<typename SetDefaultPolicyVersionRequestT = Model::SetDefaultPolicyVersionRequest>
        Model::SetDefaultPolicyVersionOutcomeCallable SetDefaultPolicyVersionCallable(const SetDefaultPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::SetDefaultPolicyVersion, request);
        }
 
        template<typename SetDefaultPolicyVersionRequestT = Model::SetDefaultPolicyVersionRequest>
        void SetDefaultPolicyVersionAsync(const SetDefaultPolicyVersionRequestT& request, const SetDefaultPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::SetDefaultPolicyVersion, request, handler, context);
        }
 
        virtual Model::SetLoggingOptionsOutcome SetLoggingOptions(const Model::SetLoggingOptionsRequest& request) const;
 
        template<typename SetLoggingOptionsRequestT = Model::SetLoggingOptionsRequest>
        Model::SetLoggingOptionsOutcomeCallable SetLoggingOptionsCallable(const SetLoggingOptionsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::SetLoggingOptions, request);
        }
 
        template<typename SetLoggingOptionsRequestT = Model::SetLoggingOptionsRequest>
        void SetLoggingOptionsAsync(const SetLoggingOptionsRequestT& request, const SetLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::SetLoggingOptions, request, handler, context);
        }
 
        virtual Model::SetV2LoggingLevelOutcome SetV2LoggingLevel(const Model::SetV2LoggingLevelRequest& request) const;
 
        template<typename SetV2LoggingLevelRequestT = Model::SetV2LoggingLevelRequest>
        Model::SetV2LoggingLevelOutcomeCallable SetV2LoggingLevelCallable(const SetV2LoggingLevelRequestT& request) const
        {
            return SubmitCallable(&IoTClient::SetV2LoggingLevel, request);
        }
 
        template<typename SetV2LoggingLevelRequestT = Model::SetV2LoggingLevelRequest>
        void SetV2LoggingLevelAsync(const SetV2LoggingLevelRequestT& request, const SetV2LoggingLevelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::SetV2LoggingLevel, request, handler, context);
        }
 
        virtual Model::SetV2LoggingOptionsOutcome SetV2LoggingOptions(const Model::SetV2LoggingOptionsRequest& request = {}) const;
 
        template<typename SetV2LoggingOptionsRequestT = Model::SetV2LoggingOptionsRequest>
        Model::SetV2LoggingOptionsOutcomeCallable SetV2LoggingOptionsCallable(const SetV2LoggingOptionsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::SetV2LoggingOptions, request);
        }
 
        template<typename SetV2LoggingOptionsRequestT = Model::SetV2LoggingOptionsRequest>
        void SetV2LoggingOptionsAsync(const SetV2LoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SetV2LoggingOptionsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::SetV2LoggingOptions, request, handler, context);
        }
 
        virtual Model::StartAuditMitigationActionsTaskOutcome StartAuditMitigationActionsTask(const Model::StartAuditMitigationActionsTaskRequest& request) const;
 
        template<typename StartAuditMitigationActionsTaskRequestT = Model::StartAuditMitigationActionsTaskRequest>
        Model::StartAuditMitigationActionsTaskOutcomeCallable StartAuditMitigationActionsTaskCallable(const StartAuditMitigationActionsTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::StartAuditMitigationActionsTask, request);
        }
 
        template<typename StartAuditMitigationActionsTaskRequestT = Model::StartAuditMitigationActionsTaskRequest>
        void StartAuditMitigationActionsTaskAsync(const StartAuditMitigationActionsTaskRequestT& request, const StartAuditMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::StartAuditMitigationActionsTask, request, handler, context);
        }
 
        virtual Model::StartDetectMitigationActionsTaskOutcome StartDetectMitigationActionsTask(const Model::StartDetectMitigationActionsTaskRequest& request) const;
 
        template<typename StartDetectMitigationActionsTaskRequestT = Model::StartDetectMitigationActionsTaskRequest>
        Model::StartDetectMitigationActionsTaskOutcomeCallable StartDetectMitigationActionsTaskCallable(const StartDetectMitigationActionsTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::StartDetectMitigationActionsTask, request);
        }
 
        template<typename StartDetectMitigationActionsTaskRequestT = Model::StartDetectMitigationActionsTaskRequest>
        void StartDetectMitigationActionsTaskAsync(const StartDetectMitigationActionsTaskRequestT& request, const StartDetectMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::StartDetectMitigationActionsTask, request, handler, context);
        }
 
        virtual Model::StartOnDemandAuditTaskOutcome StartOnDemandAuditTask(const Model::StartOnDemandAuditTaskRequest& request) const;
 
        template<typename StartOnDemandAuditTaskRequestT = Model::StartOnDemandAuditTaskRequest>
        Model::StartOnDemandAuditTaskOutcomeCallable StartOnDemandAuditTaskCallable(const StartOnDemandAuditTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::StartOnDemandAuditTask, request);
        }
 
        template<typename StartOnDemandAuditTaskRequestT = Model::StartOnDemandAuditTaskRequest>
        void StartOnDemandAuditTaskAsync(const StartOnDemandAuditTaskRequestT& request, const StartOnDemandAuditTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::StartOnDemandAuditTask, request, handler, context);
        }
 
        virtual Model::StartThingRegistrationTaskOutcome StartThingRegistrationTask(const Model::StartThingRegistrationTaskRequest& request) const;
 
        template<typename StartThingRegistrationTaskRequestT = Model::StartThingRegistrationTaskRequest>
        Model::StartThingRegistrationTaskOutcomeCallable StartThingRegistrationTaskCallable(const StartThingRegistrationTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::StartThingRegistrationTask, request);
        }
 
        template<typename StartThingRegistrationTaskRequestT = Model::StartThingRegistrationTaskRequest>
        void StartThingRegistrationTaskAsync(const StartThingRegistrationTaskRequestT& request, const StartThingRegistrationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::StartThingRegistrationTask, request, handler, context);
        }
 
        virtual Model::StopThingRegistrationTaskOutcome StopThingRegistrationTask(const Model::StopThingRegistrationTaskRequest& request) const;
 
        template<typename StopThingRegistrationTaskRequestT = Model::StopThingRegistrationTaskRequest>
        Model::StopThingRegistrationTaskOutcomeCallable StopThingRegistrationTaskCallable(const StopThingRegistrationTaskRequestT& request) const
        {
            return SubmitCallable(&IoTClient::StopThingRegistrationTask, request);
        }
 
        template<typename StopThingRegistrationTaskRequestT = Model::StopThingRegistrationTaskRequest>
        void StopThingRegistrationTaskAsync(const StopThingRegistrationTaskRequestT& request, const StopThingRegistrationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::StopThingRegistrationTask, 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(&IoTClient::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(&IoTClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestAuthorizationOutcome TestAuthorization(const Model::TestAuthorizationRequest& request) const;
 
        template<typename TestAuthorizationRequestT = Model::TestAuthorizationRequest>
        Model::TestAuthorizationOutcomeCallable TestAuthorizationCallable(const TestAuthorizationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::TestAuthorization, request);
        }
 
        template<typename TestAuthorizationRequestT = Model::TestAuthorizationRequest>
        void TestAuthorizationAsync(const TestAuthorizationRequestT& request, const TestAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::TestAuthorization, request, handler, context);
        }
 
        virtual Model::TestInvokeAuthorizerOutcome TestInvokeAuthorizer(const Model::TestInvokeAuthorizerRequest& request) const;
 
        template<typename TestInvokeAuthorizerRequestT = Model::TestInvokeAuthorizerRequest>
        Model::TestInvokeAuthorizerOutcomeCallable TestInvokeAuthorizerCallable(const TestInvokeAuthorizerRequestT& request) const
        {
            return SubmitCallable(&IoTClient::TestInvokeAuthorizer, request);
        }
 
        template<typename TestInvokeAuthorizerRequestT = Model::TestInvokeAuthorizerRequest>
        void TestInvokeAuthorizerAsync(const TestInvokeAuthorizerRequestT& request, const TestInvokeAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::TestInvokeAuthorizer, request, handler, context);
        }
 
        virtual Model::TransferCertificateOutcome TransferCertificate(const Model::TransferCertificateRequest& request) const;
 
        template<typename TransferCertificateRequestT = Model::TransferCertificateRequest>
        Model::TransferCertificateOutcomeCallable TransferCertificateCallable(const TransferCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::TransferCertificate, request);
        }
 
        template<typename TransferCertificateRequestT = Model::TransferCertificateRequest>
        void TransferCertificateAsync(const TransferCertificateRequestT& request, const TransferCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::TransferCertificate, 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(&IoTClient::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(&IoTClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAccountAuditConfigurationOutcome UpdateAccountAuditConfiguration(const Model::UpdateAccountAuditConfigurationRequest& request = {}) const;
 
        template<typename UpdateAccountAuditConfigurationRequestT = Model::UpdateAccountAuditConfigurationRequest>
        Model::UpdateAccountAuditConfigurationOutcomeCallable UpdateAccountAuditConfigurationCallable(const UpdateAccountAuditConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::UpdateAccountAuditConfiguration, request);
        }
 
        template<typename UpdateAccountAuditConfigurationRequestT = Model::UpdateAccountAuditConfigurationRequest>
        void UpdateAccountAuditConfigurationAsync(const UpdateAccountAuditConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAccountAuditConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::UpdateAccountAuditConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateAuditSuppressionOutcome UpdateAuditSuppression(const Model::UpdateAuditSuppressionRequest& request) const;
 
        template<typename UpdateAuditSuppressionRequestT = Model::UpdateAuditSuppressionRequest>
        Model::UpdateAuditSuppressionOutcomeCallable UpdateAuditSuppressionCallable(const UpdateAuditSuppressionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateAuditSuppression, request);
        }
 
        template<typename UpdateAuditSuppressionRequestT = Model::UpdateAuditSuppressionRequest>
        void UpdateAuditSuppressionAsync(const UpdateAuditSuppressionRequestT& request, const UpdateAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateAuditSuppression, request, handler, context);
        }
 
        virtual Model::UpdateAuthorizerOutcome UpdateAuthorizer(const Model::UpdateAuthorizerRequest& request) const;
 
        template<typename UpdateAuthorizerRequestT = Model::UpdateAuthorizerRequest>
        Model::UpdateAuthorizerOutcomeCallable UpdateAuthorizerCallable(const UpdateAuthorizerRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateAuthorizer, request);
        }
 
        template<typename UpdateAuthorizerRequestT = Model::UpdateAuthorizerRequest>
        void UpdateAuthorizerAsync(const UpdateAuthorizerRequestT& request, const UpdateAuthorizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateAuthorizer, request, handler, context);
        }
 
        virtual Model::UpdateBillingGroupOutcome UpdateBillingGroup(const Model::UpdateBillingGroupRequest& request) const;
 
        template<typename UpdateBillingGroupRequestT = Model::UpdateBillingGroupRequest>
        Model::UpdateBillingGroupOutcomeCallable UpdateBillingGroupCallable(const UpdateBillingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateBillingGroup, request);
        }
 
        template<typename UpdateBillingGroupRequestT = Model::UpdateBillingGroupRequest>
        void UpdateBillingGroupAsync(const UpdateBillingGroupRequestT& request, const UpdateBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateBillingGroup, request, handler, context);
        }
 
        virtual Model::UpdateCACertificateOutcome UpdateCACertificate(const Model::UpdateCACertificateRequest& request) const;
 
        template<typename UpdateCACertificateRequestT = Model::UpdateCACertificateRequest>
        Model::UpdateCACertificateOutcomeCallable UpdateCACertificateCallable(const UpdateCACertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateCACertificate, request);
        }
 
        template<typename UpdateCACertificateRequestT = Model::UpdateCACertificateRequest>
        void UpdateCACertificateAsync(const UpdateCACertificateRequestT& request, const UpdateCACertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateCACertificate, request, handler, context);
        }
 
        virtual Model::UpdateCertificateOutcome UpdateCertificate(const Model::UpdateCertificateRequest& request) const;
 
        template<typename UpdateCertificateRequestT = Model::UpdateCertificateRequest>
        Model::UpdateCertificateOutcomeCallable UpdateCertificateCallable(const UpdateCertificateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateCertificate, request);
        }
 
        template<typename UpdateCertificateRequestT = Model::UpdateCertificateRequest>
        void UpdateCertificateAsync(const UpdateCertificateRequestT& request, const UpdateCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateCertificate, request, handler, context);
        }
 
        virtual Model::UpdateCertificateProviderOutcome UpdateCertificateProvider(const Model::UpdateCertificateProviderRequest& request) const;
 
        template<typename UpdateCertificateProviderRequestT = Model::UpdateCertificateProviderRequest>
        Model::UpdateCertificateProviderOutcomeCallable UpdateCertificateProviderCallable(const UpdateCertificateProviderRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateCertificateProvider, request);
        }
 
        template<typename UpdateCertificateProviderRequestT = Model::UpdateCertificateProviderRequest>
        void UpdateCertificateProviderAsync(const UpdateCertificateProviderRequestT& request, const UpdateCertificateProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateCertificateProvider, request, handler, context);
        }
 
        virtual Model::UpdateCommandOutcome UpdateCommand(const Model::UpdateCommandRequest& request) const;
 
        template<typename UpdateCommandRequestT = Model::UpdateCommandRequest>
        Model::UpdateCommandOutcomeCallable UpdateCommandCallable(const UpdateCommandRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateCommand, request);
        }
 
        template<typename UpdateCommandRequestT = Model::UpdateCommandRequest>
        void UpdateCommandAsync(const UpdateCommandRequestT& request, const UpdateCommandResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateCommand, request, handler, context);
        }
 
        virtual Model::UpdateCustomMetricOutcome UpdateCustomMetric(const Model::UpdateCustomMetricRequest& request) const;
 
        template<typename UpdateCustomMetricRequestT = Model::UpdateCustomMetricRequest>
        Model::UpdateCustomMetricOutcomeCallable UpdateCustomMetricCallable(const UpdateCustomMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateCustomMetric, request);
        }
 
        template<typename UpdateCustomMetricRequestT = Model::UpdateCustomMetricRequest>
        void UpdateCustomMetricAsync(const UpdateCustomMetricRequestT& request, const UpdateCustomMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateCustomMetric, request, handler, context);
        }
 
        virtual Model::UpdateDimensionOutcome UpdateDimension(const Model::UpdateDimensionRequest& request) const;
 
        template<typename UpdateDimensionRequestT = Model::UpdateDimensionRequest>
        Model::UpdateDimensionOutcomeCallable UpdateDimensionCallable(const UpdateDimensionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateDimension, request);
        }
 
        template<typename UpdateDimensionRequestT = Model::UpdateDimensionRequest>
        void UpdateDimensionAsync(const UpdateDimensionRequestT& request, const UpdateDimensionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateDimension, request, handler, context);
        }
 
        virtual Model::UpdateDomainConfigurationOutcome UpdateDomainConfiguration(const Model::UpdateDomainConfigurationRequest& request) const;
 
        template<typename UpdateDomainConfigurationRequestT = Model::UpdateDomainConfigurationRequest>
        Model::UpdateDomainConfigurationOutcomeCallable UpdateDomainConfigurationCallable(const UpdateDomainConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateDomainConfiguration, request);
        }
 
        template<typename UpdateDomainConfigurationRequestT = Model::UpdateDomainConfigurationRequest>
        void UpdateDomainConfigurationAsync(const UpdateDomainConfigurationRequestT& request, const UpdateDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateDomainConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateDynamicThingGroupOutcome UpdateDynamicThingGroup(const Model::UpdateDynamicThingGroupRequest& request) const;
 
        template<typename UpdateDynamicThingGroupRequestT = Model::UpdateDynamicThingGroupRequest>
        Model::UpdateDynamicThingGroupOutcomeCallable UpdateDynamicThingGroupCallable(const UpdateDynamicThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateDynamicThingGroup, request);
        }
 
        template<typename UpdateDynamicThingGroupRequestT = Model::UpdateDynamicThingGroupRequest>
        void UpdateDynamicThingGroupAsync(const UpdateDynamicThingGroupRequestT& request, const UpdateDynamicThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateDynamicThingGroup, request, handler, context);
        }
 
        virtual Model::UpdateEncryptionConfigurationOutcome UpdateEncryptionConfiguration(const Model::UpdateEncryptionConfigurationRequest& request) const;
 
        template<typename UpdateEncryptionConfigurationRequestT = Model::UpdateEncryptionConfigurationRequest>
        Model::UpdateEncryptionConfigurationOutcomeCallable UpdateEncryptionConfigurationCallable(const UpdateEncryptionConfigurationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateEncryptionConfiguration, request);
        }
 
        template<typename UpdateEncryptionConfigurationRequestT = Model::UpdateEncryptionConfigurationRequest>
        void UpdateEncryptionConfigurationAsync(const UpdateEncryptionConfigurationRequestT& request, const UpdateEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateEncryptionConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateEventConfigurationsOutcome UpdateEventConfigurations(const Model::UpdateEventConfigurationsRequest& request = {}) const;
 
        template<typename UpdateEventConfigurationsRequestT = Model::UpdateEventConfigurationsRequest>
        Model::UpdateEventConfigurationsOutcomeCallable UpdateEventConfigurationsCallable(const UpdateEventConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::UpdateEventConfigurations, request);
        }
 
        template<typename UpdateEventConfigurationsRequestT = Model::UpdateEventConfigurationsRequest>
        void UpdateEventConfigurationsAsync(const UpdateEventConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateEventConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::UpdateEventConfigurations, request, handler, context);
        }
 
        virtual Model::UpdateFleetMetricOutcome UpdateFleetMetric(const Model::UpdateFleetMetricRequest& request) const;
 
        template<typename UpdateFleetMetricRequestT = Model::UpdateFleetMetricRequest>
        Model::UpdateFleetMetricOutcomeCallable UpdateFleetMetricCallable(const UpdateFleetMetricRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateFleetMetric, request);
        }
 
        template<typename UpdateFleetMetricRequestT = Model::UpdateFleetMetricRequest>
        void UpdateFleetMetricAsync(const UpdateFleetMetricRequestT& request, const UpdateFleetMetricResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateFleetMetric, request, handler, context);
        }
 
        virtual Model::UpdateIndexingConfigurationOutcome UpdateIndexingConfiguration(const Model::UpdateIndexingConfigurationRequest& request = {}) const;
 
        template<typename UpdateIndexingConfigurationRequestT = Model::UpdateIndexingConfigurationRequest>
        Model::UpdateIndexingConfigurationOutcomeCallable UpdateIndexingConfigurationCallable(const UpdateIndexingConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::UpdateIndexingConfiguration, request);
        }
 
        template<typename UpdateIndexingConfigurationRequestT = Model::UpdateIndexingConfigurationRequest>
        void UpdateIndexingConfigurationAsync(const UpdateIndexingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateIndexingConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::UpdateIndexingConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateJobOutcome UpdateJob(const Model::UpdateJobRequest& request) const;
 
        template<typename UpdateJobRequestT = Model::UpdateJobRequest>
        Model::UpdateJobOutcomeCallable UpdateJobCallable(const UpdateJobRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateJob, request);
        }
 
        template<typename UpdateJobRequestT = Model::UpdateJobRequest>
        void UpdateJobAsync(const UpdateJobRequestT& request, const UpdateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateJob, request, handler, context);
        }
 
        virtual Model::UpdateMitigationActionOutcome UpdateMitigationAction(const Model::UpdateMitigationActionRequest& request) const;
 
        template<typename UpdateMitigationActionRequestT = Model::UpdateMitigationActionRequest>
        Model::UpdateMitigationActionOutcomeCallable UpdateMitigationActionCallable(const UpdateMitigationActionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateMitigationAction, request);
        }
 
        template<typename UpdateMitigationActionRequestT = Model::UpdateMitigationActionRequest>
        void UpdateMitigationActionAsync(const UpdateMitigationActionRequestT& request, const UpdateMitigationActionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateMitigationAction, request, handler, context);
        }
 
        virtual Model::UpdatePackageOutcome UpdatePackage(const Model::UpdatePackageRequest& request) const;
 
        template<typename UpdatePackageRequestT = Model::UpdatePackageRequest>
        Model::UpdatePackageOutcomeCallable UpdatePackageCallable(const UpdatePackageRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdatePackage, request);
        }
 
        template<typename UpdatePackageRequestT = Model::UpdatePackageRequest>
        void UpdatePackageAsync(const UpdatePackageRequestT& request, const UpdatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdatePackage, request, handler, context);
        }
 
        virtual Model::UpdatePackageConfigurationOutcome UpdatePackageConfiguration(const Model::UpdatePackageConfigurationRequest& request = {}) const;
 
        template<typename UpdatePackageConfigurationRequestT = Model::UpdatePackageConfigurationRequest>
        Model::UpdatePackageConfigurationOutcomeCallable UpdatePackageConfigurationCallable(const UpdatePackageConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::UpdatePackageConfiguration, request);
        }
 
        template<typename UpdatePackageConfigurationRequestT = Model::UpdatePackageConfigurationRequest>
        void UpdatePackageConfigurationAsync(const UpdatePackageConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdatePackageConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::UpdatePackageConfiguration, request, handler, context);
        }
 
        virtual Model::UpdatePackageVersionOutcome UpdatePackageVersion(const Model::UpdatePackageVersionRequest& request) const;
 
        template<typename UpdatePackageVersionRequestT = Model::UpdatePackageVersionRequest>
        Model::UpdatePackageVersionOutcomeCallable UpdatePackageVersionCallable(const UpdatePackageVersionRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdatePackageVersion, request);
        }
 
        template<typename UpdatePackageVersionRequestT = Model::UpdatePackageVersionRequest>
        void UpdatePackageVersionAsync(const UpdatePackageVersionRequestT& request, const UpdatePackageVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdatePackageVersion, request, handler, context);
        }
 
        virtual Model::UpdateProvisioningTemplateOutcome UpdateProvisioningTemplate(const Model::UpdateProvisioningTemplateRequest& request) const;
 
        template<typename UpdateProvisioningTemplateRequestT = Model::UpdateProvisioningTemplateRequest>
        Model::UpdateProvisioningTemplateOutcomeCallable UpdateProvisioningTemplateCallable(const UpdateProvisioningTemplateRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateProvisioningTemplate, request);
        }
 
        template<typename UpdateProvisioningTemplateRequestT = Model::UpdateProvisioningTemplateRequest>
        void UpdateProvisioningTemplateAsync(const UpdateProvisioningTemplateRequestT& request, const UpdateProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateProvisioningTemplate, request, handler, context);
        }
 
        virtual Model::UpdateRoleAliasOutcome UpdateRoleAlias(const Model::UpdateRoleAliasRequest& request) const;
 
        template<typename UpdateRoleAliasRequestT = Model::UpdateRoleAliasRequest>
        Model::UpdateRoleAliasOutcomeCallable UpdateRoleAliasCallable(const UpdateRoleAliasRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateRoleAlias, request);
        }
 
        template<typename UpdateRoleAliasRequestT = Model::UpdateRoleAliasRequest>
        void UpdateRoleAliasAsync(const UpdateRoleAliasRequestT& request, const UpdateRoleAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateRoleAlias, request, handler, context);
        }
 
        virtual Model::UpdateScheduledAuditOutcome UpdateScheduledAudit(const Model::UpdateScheduledAuditRequest& request) const;
 
        template<typename UpdateScheduledAuditRequestT = Model::UpdateScheduledAuditRequest>
        Model::UpdateScheduledAuditOutcomeCallable UpdateScheduledAuditCallable(const UpdateScheduledAuditRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateScheduledAudit, request);
        }
 
        template<typename UpdateScheduledAuditRequestT = Model::UpdateScheduledAuditRequest>
        void UpdateScheduledAuditAsync(const UpdateScheduledAuditRequestT& request, const UpdateScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateScheduledAudit, request, handler, context);
        }
 
        virtual Model::UpdateSecurityProfileOutcome UpdateSecurityProfile(const Model::UpdateSecurityProfileRequest& request) const;
 
        template<typename UpdateSecurityProfileRequestT = Model::UpdateSecurityProfileRequest>
        Model::UpdateSecurityProfileOutcomeCallable UpdateSecurityProfileCallable(const UpdateSecurityProfileRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateSecurityProfile, request);
        }
 
        template<typename UpdateSecurityProfileRequestT = Model::UpdateSecurityProfileRequest>
        void UpdateSecurityProfileAsync(const UpdateSecurityProfileRequestT& request, const UpdateSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateSecurityProfile, request, handler, context);
        }
 
        virtual Model::UpdateStreamOutcome UpdateStream(const Model::UpdateStreamRequest& request) const;
 
        template<typename UpdateStreamRequestT = Model::UpdateStreamRequest>
        Model::UpdateStreamOutcomeCallable UpdateStreamCallable(const UpdateStreamRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateStream, request);
        }
 
        template<typename UpdateStreamRequestT = Model::UpdateStreamRequest>
        void UpdateStreamAsync(const UpdateStreamRequestT& request, const UpdateStreamResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateStream, request, handler, context);
        }
 
        virtual Model::UpdateThingOutcome UpdateThing(const Model::UpdateThingRequest& request) const;
 
        template<typename UpdateThingRequestT = Model::UpdateThingRequest>
        Model::UpdateThingOutcomeCallable UpdateThingCallable(const UpdateThingRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateThing, request);
        }
 
        template<typename UpdateThingRequestT = Model::UpdateThingRequest>
        void UpdateThingAsync(const UpdateThingRequestT& request, const UpdateThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateThing, request, handler, context);
        }
 
        virtual Model::UpdateThingGroupOutcome UpdateThingGroup(const Model::UpdateThingGroupRequest& request) const;
 
        template<typename UpdateThingGroupRequestT = Model::UpdateThingGroupRequest>
        Model::UpdateThingGroupOutcomeCallable UpdateThingGroupCallable(const UpdateThingGroupRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateThingGroup, request);
        }
 
        template<typename UpdateThingGroupRequestT = Model::UpdateThingGroupRequest>
        void UpdateThingGroupAsync(const UpdateThingGroupRequestT& request, const UpdateThingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateThingGroup, request, handler, context);
        }
 
        virtual Model::UpdateThingGroupsForThingOutcome UpdateThingGroupsForThing(const Model::UpdateThingGroupsForThingRequest& request = {}) const;
 
        template<typename UpdateThingGroupsForThingRequestT = Model::UpdateThingGroupsForThingRequest>
        Model::UpdateThingGroupsForThingOutcomeCallable UpdateThingGroupsForThingCallable(const UpdateThingGroupsForThingRequestT& request = {}) const
        {
            return SubmitCallable(&IoTClient::UpdateThingGroupsForThing, request);
        }
 
        template<typename UpdateThingGroupsForThingRequestT = Model::UpdateThingGroupsForThingRequest>
        void UpdateThingGroupsForThingAsync(const UpdateThingGroupsForThingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateThingGroupsForThingRequestT& request = {}) const
        {
            return SubmitAsync(&IoTClient::UpdateThingGroupsForThing, request, handler, context);
        }
 
        virtual Model::UpdateThingTypeOutcome UpdateThingType(const Model::UpdateThingTypeRequest& request) const;
 
        template<typename UpdateThingTypeRequestT = Model::UpdateThingTypeRequest>
        Model::UpdateThingTypeOutcomeCallable UpdateThingTypeCallable(const UpdateThingTypeRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateThingType, request);
        }
 
        template<typename UpdateThingTypeRequestT = Model::UpdateThingTypeRequest>
        void UpdateThingTypeAsync(const UpdateThingTypeRequestT& request, const UpdateThingTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateThingType, request, handler, context);
        }
 
        virtual Model::UpdateTopicRuleDestinationOutcome UpdateTopicRuleDestination(const Model::UpdateTopicRuleDestinationRequest& request) const;
 
        template<typename UpdateTopicRuleDestinationRequestT = Model::UpdateTopicRuleDestinationRequest>
        Model::UpdateTopicRuleDestinationOutcomeCallable UpdateTopicRuleDestinationCallable(const UpdateTopicRuleDestinationRequestT& request) const
        {
            return SubmitCallable(&IoTClient::UpdateTopicRuleDestination, request);
        }
 
        template<typename UpdateTopicRuleDestinationRequestT = Model::UpdateTopicRuleDestinationRequest>
        void UpdateTopicRuleDestinationAsync(const UpdateTopicRuleDestinationRequestT& request, const UpdateTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::UpdateTopicRuleDestination, request, handler, context);
        }
 
        virtual Model::ValidateSecurityProfileBehaviorsOutcome ValidateSecurityProfileBehaviors(const Model::ValidateSecurityProfileBehaviorsRequest& request) const;
 
        template<typename ValidateSecurityProfileBehaviorsRequestT = Model::ValidateSecurityProfileBehaviorsRequest>
        Model::ValidateSecurityProfileBehaviorsOutcomeCallable ValidateSecurityProfileBehaviorsCallable(const ValidateSecurityProfileBehaviorsRequestT& request) const
        {
            return SubmitCallable(&IoTClient::ValidateSecurityProfileBehaviors, request);
        }
 
        template<typename ValidateSecurityProfileBehaviorsRequestT = Model::ValidateSecurityProfileBehaviorsRequest>
        void ValidateSecurityProfileBehaviorsAsync(const ValidateSecurityProfileBehaviorsRequestT& request, const ValidateSecurityProfileBehaviorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&IoTClient::ValidateSecurityProfileBehaviors, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<IoTEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<IoTClient>;
      void init(const IoTClientConfiguration& clientConfiguration);
 
      IoTClientConfiguration m_clientConfiguration;
      std::shared_ptr<IoTEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace IoT
} // namespace Aws