IoTClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/iot/IoTPaginationBase.h>
#include <aws/iot/IoTServiceClientModel.h>
#include <aws/iot/IoT_EXPORTS.h>
 
namespace Aws {
namespace IoT {
class AWS_IOT_API IoTClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<IoTClient>,
                              public IoTPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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