/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace IoT { /** * IoT

IoT provides secure, bi-directional communication * between Internet-connected devices (such as sensors, actuators, embedded * devices, or smart appliances) and the Amazon Web Services cloud. You can * discover your custom IoT-Data endpoint to communicate with, configure rules for * data processing and integration with other services, organize resources * associated with each device (Registry), configure logging, and create and manage * policies and credentials to authenticate devices.

The service endpoints * that expose this API are listed in Amazon Web * Services IoT Core Endpoints and Quotas. You must use the endpoint for the * region that has the resources you want to access.

The service name used * by Amazon * Web Services Signature Version 4 to sign the request is: * execute-api.

For more information about how IoT works, see the Developer * Guide.

For information about how to use the credentials provider for * IoT, see Authorizing * Direct Calls to Amazon Web Services Services.

*/ class AWS_IOT_API IoTClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef IoTClientConfiguration ClientConfigurationType; typedef IoTEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ IoTClient(const Aws::IoT::IoTClientConfiguration& clientConfiguration = Aws::IoT::IoTClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ IoTClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::IoT::IoTClientConfiguration& clientConfiguration = Aws::IoT::IoTClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ IoTClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::IoT::IoTClientConfiguration& clientConfiguration = Aws::IoT::IoTClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ IoTClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ IoTClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ IoTClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~IoTClient(); /** *

Accepts a pending certificate transfer. The default state of the certificate * is INACTIVE.

To check for pending certificate transfers, call * ListCertificates to enumerate your certificates.

Requires * permission to access the AcceptCertificateTransfer * action.

See Also:

AWS * API Reference

*/ virtual Model::AcceptCertificateTransferOutcome AcceptCertificateTransfer(const Model::AcceptCertificateTransferRequest& request) const; /** * A Callable wrapper for AcceptCertificateTransfer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptCertificateTransferOutcomeCallable AcceptCertificateTransferCallable(const AcceptCertificateTransferRequestT& request) const { return SubmitCallable(&IoTClient::AcceptCertificateTransfer, request); } /** * An Async wrapper for AcceptCertificateTransfer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptCertificateTransferAsync(const AcceptCertificateTransferRequestT& request, const AcceptCertificateTransferResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AcceptCertificateTransfer, request, handler, context); } /** *

Adds a thing to a billing group.

Requires permission to access the AddThingToBillingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::AddThingToBillingGroupOutcome AddThingToBillingGroup(const Model::AddThingToBillingGroupRequest& request) const; /** * A Callable wrapper for AddThingToBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddThingToBillingGroupOutcomeCallable AddThingToBillingGroupCallable(const AddThingToBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::AddThingToBillingGroup, request); } /** * An Async wrapper for AddThingToBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddThingToBillingGroupAsync(const AddThingToBillingGroupRequestT& request, const AddThingToBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AddThingToBillingGroup, request, handler, context); } /** *

Adds a thing to a thing group.

Requires permission to access the AddThingToThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::AddThingToThingGroupOutcome AddThingToThingGroup(const Model::AddThingToThingGroupRequest& request) const; /** * A Callable wrapper for AddThingToThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddThingToThingGroupOutcomeCallable AddThingToThingGroupCallable(const AddThingToThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::AddThingToThingGroup, request); } /** * An Async wrapper for AddThingToThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddThingToThingGroupAsync(const AddThingToThingGroupRequestT& request, const AddThingToThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AddThingToThingGroup, request, handler, context); } /** *

Associates a group with a continuous job. The following criteria must be met: *

  • The job must have been created with the * targetSelection field set to "CONTINUOUS".

  • The * job status must currently be "IN_PROGRESS".

  • The total number * of targets associated with a job must not exceed 100.

*

Requires permission to access the AssociateTargetsWithJob * action.

See Also:

AWS * API Reference

*/ virtual Model::AssociateTargetsWithJobOutcome AssociateTargetsWithJob(const Model::AssociateTargetsWithJobRequest& request) const; /** * A Callable wrapper for AssociateTargetsWithJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTargetsWithJobOutcomeCallable AssociateTargetsWithJobCallable(const AssociateTargetsWithJobRequestT& request) const { return SubmitCallable(&IoTClient::AssociateTargetsWithJob, request); } /** * An Async wrapper for AssociateTargetsWithJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTargetsWithJobAsync(const AssociateTargetsWithJobRequestT& request, const AssociateTargetsWithJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AssociateTargetsWithJob, request, handler, context); } /** *

Attaches the specified policy to the specified principal (certificate or * other credential).

Requires permission to access the AttachPolicy * action.

See Also:

AWS * API Reference

*/ virtual Model::AttachPolicyOutcome AttachPolicy(const Model::AttachPolicyRequest& request) const; /** * A Callable wrapper for AttachPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachPolicyOutcomeCallable AttachPolicyCallable(const AttachPolicyRequestT& request) const { return SubmitCallable(&IoTClient::AttachPolicy, request); } /** * An Async wrapper for AttachPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachPolicyAsync(const AttachPolicyRequestT& request, const AttachPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AttachPolicy, request, handler, context); } /** *

Associates a Device Defender security profile with a thing group or this * account. Each thing group or account can have up to five security profiles * associated with it.

Requires permission to access the AttachSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::AttachSecurityProfileOutcome AttachSecurityProfile(const Model::AttachSecurityProfileRequest& request) const; /** * A Callable wrapper for AttachSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachSecurityProfileOutcomeCallable AttachSecurityProfileCallable(const AttachSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::AttachSecurityProfile, request); } /** * An Async wrapper for AttachSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachSecurityProfileAsync(const AttachSecurityProfileRequestT& request, const AttachSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AttachSecurityProfile, request, handler, context); } /** *

Attaches the specified principal to the specified thing. A principal can be * X.509 certificates, Amazon Cognito identities or federated identities.

*

Requires permission to access the AttachThingPrincipal * action.

See Also:

AWS * API Reference

*/ virtual Model::AttachThingPrincipalOutcome AttachThingPrincipal(const Model::AttachThingPrincipalRequest& request) const; /** * A Callable wrapper for AttachThingPrincipal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachThingPrincipalOutcomeCallable AttachThingPrincipalCallable(const AttachThingPrincipalRequestT& request) const { return SubmitCallable(&IoTClient::AttachThingPrincipal, request); } /** * An Async wrapper for AttachThingPrincipal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachThingPrincipalAsync(const AttachThingPrincipalRequestT& request, const AttachThingPrincipalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::AttachThingPrincipal, request, handler, context); } /** *

Cancels a mitigation action task that is in progress. If the task is not in * progress, an InvalidRequestException occurs.

Requires permission to * access the CancelAuditMitigationActionsTask * action.

See Also:

AWS * API Reference

*/ virtual Model::CancelAuditMitigationActionsTaskOutcome CancelAuditMitigationActionsTask(const Model::CancelAuditMitigationActionsTaskRequest& request) const; /** * A Callable wrapper for CancelAuditMitigationActionsTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelAuditMitigationActionsTaskOutcomeCallable CancelAuditMitigationActionsTaskCallable(const CancelAuditMitigationActionsTaskRequestT& request) const { return SubmitCallable(&IoTClient::CancelAuditMitigationActionsTask, request); } /** * An Async wrapper for CancelAuditMitigationActionsTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelAuditMitigationActionsTaskAsync(const CancelAuditMitigationActionsTaskRequestT& request, const CancelAuditMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CancelAuditMitigationActionsTask, request, handler, context); } /** *

Cancels an audit that is in progress. The audit can be either scheduled or on * demand. If the audit isn't in progress, an "InvalidRequestException" occurs.

*

Requires permission to access the CancelAuditTask * action.

See Also:

AWS * API Reference

*/ virtual Model::CancelAuditTaskOutcome CancelAuditTask(const Model::CancelAuditTaskRequest& request) const; /** * A Callable wrapper for CancelAuditTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelAuditTaskOutcomeCallable CancelAuditTaskCallable(const CancelAuditTaskRequestT& request) const { return SubmitCallable(&IoTClient::CancelAuditTask, request); } /** * An Async wrapper for CancelAuditTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelAuditTaskAsync(const CancelAuditTaskRequestT& request, const CancelAuditTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CancelAuditTask, request, handler, context); } /** *

Cancels a pending transfer for the specified certificate.

Note * Only the transfer source account can use this operation to cancel a transfer. * (Transfer destinations can use RejectCertificateTransfer instead.) After * transfer, IoT returns the certificate to the source account in the INACTIVE * state. After the destination account has accepted the transfer, the transfer * cannot be cancelled.

After a certificate transfer is cancelled, the * status of the certificate changes from PENDING_TRANSFER to INACTIVE.

*

Requires permission to access the CancelCertificateTransfer * action.

See Also:

AWS * API Reference

*/ virtual Model::CancelCertificateTransferOutcome CancelCertificateTransfer(const Model::CancelCertificateTransferRequest& request) const; /** * A Callable wrapper for CancelCertificateTransfer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelCertificateTransferOutcomeCallable CancelCertificateTransferCallable(const CancelCertificateTransferRequestT& request) const { return SubmitCallable(&IoTClient::CancelCertificateTransfer, request); } /** * An Async wrapper for CancelCertificateTransfer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelCertificateTransferAsync(const CancelCertificateTransferRequestT& request, const CancelCertificateTransferResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CancelCertificateTransfer, request, handler, context); } /** *

Cancels a Device Defender ML Detect mitigation action.

Requires * permission to access the CancelDetectMitigationActionsTask * action.

See Also:

AWS * API Reference

*/ virtual Model::CancelDetectMitigationActionsTaskOutcome CancelDetectMitigationActionsTask(const Model::CancelDetectMitigationActionsTaskRequest& request) const; /** * A Callable wrapper for CancelDetectMitigationActionsTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelDetectMitigationActionsTaskOutcomeCallable CancelDetectMitigationActionsTaskCallable(const CancelDetectMitigationActionsTaskRequestT& request) const { return SubmitCallable(&IoTClient::CancelDetectMitigationActionsTask, request); } /** * An Async wrapper for CancelDetectMitigationActionsTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelDetectMitigationActionsTaskAsync(const CancelDetectMitigationActionsTaskRequestT& request, const CancelDetectMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CancelDetectMitigationActionsTask, request, handler, context); } /** *

Cancels a job.

Requires permission to access the CancelJob * action.

See Also:

AWS API * Reference

*/ virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const; /** * A Callable wrapper for CancelJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const { return SubmitCallable(&IoTClient::CancelJob, request); } /** * An Async wrapper for CancelJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CancelJob, request, handler, context); } /** *

Cancels the execution of a job for a given thing.

Requires permission * to access the CancelJobExecution * action.

See Also:

AWS * API Reference

*/ virtual Model::CancelJobExecutionOutcome CancelJobExecution(const Model::CancelJobExecutionRequest& request) const; /** * A Callable wrapper for CancelJobExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelJobExecutionOutcomeCallable CancelJobExecutionCallable(const CancelJobExecutionRequestT& request) const { return SubmitCallable(&IoTClient::CancelJobExecution, request); } /** * An Async wrapper for CancelJobExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelJobExecutionAsync(const CancelJobExecutionRequestT& request, const CancelJobExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CancelJobExecution, request, handler, context); } /** *

Clears the default authorizer.

Requires permission to access the ClearDefaultAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::ClearDefaultAuthorizerOutcome ClearDefaultAuthorizer(const Model::ClearDefaultAuthorizerRequest& request) const; /** * A Callable wrapper for ClearDefaultAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ClearDefaultAuthorizerOutcomeCallable ClearDefaultAuthorizerCallable(const ClearDefaultAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::ClearDefaultAuthorizer, request); } /** * An Async wrapper for ClearDefaultAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ClearDefaultAuthorizerAsync(const ClearDefaultAuthorizerRequestT& request, const ClearDefaultAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ClearDefaultAuthorizer, request, handler, context); } /** *

Confirms a topic rule destination. When you create a rule requiring a * destination, IoT sends a confirmation message to the endpoint or base address * you specify. The message includes a token which you pass back when calling * ConfirmTopicRuleDestination to confirm that you own or have access * to the endpoint.

Requires permission to access the ConfirmTopicRuleDestination * action.

See Also:

AWS * API Reference

*/ virtual Model::ConfirmTopicRuleDestinationOutcome ConfirmTopicRuleDestination(const Model::ConfirmTopicRuleDestinationRequest& request) const; /** * A Callable wrapper for ConfirmTopicRuleDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ConfirmTopicRuleDestinationOutcomeCallable ConfirmTopicRuleDestinationCallable(const ConfirmTopicRuleDestinationRequestT& request) const { return SubmitCallable(&IoTClient::ConfirmTopicRuleDestination, request); } /** * An Async wrapper for ConfirmTopicRuleDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ConfirmTopicRuleDestinationAsync(const ConfirmTopicRuleDestinationRequestT& request, const ConfirmTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ConfirmTopicRuleDestination, request, handler, context); } /** *

Creates a Device Defender audit suppression.

Requires permission to * access the CreateAuditSuppression * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateAuditSuppressionOutcome CreateAuditSuppression(const Model::CreateAuditSuppressionRequest& request) const; /** * A Callable wrapper for CreateAuditSuppression that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAuditSuppressionOutcomeCallable CreateAuditSuppressionCallable(const CreateAuditSuppressionRequestT& request) const { return SubmitCallable(&IoTClient::CreateAuditSuppression, request); } /** * An Async wrapper for CreateAuditSuppression that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAuditSuppressionAsync(const CreateAuditSuppressionRequestT& request, const CreateAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateAuditSuppression, request, handler, context); } /** *

Creates an authorizer.

Requires permission to access the CreateAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateAuthorizerOutcome CreateAuthorizer(const Model::CreateAuthorizerRequest& request) const; /** * A Callable wrapper for CreateAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAuthorizerOutcomeCallable CreateAuthorizerCallable(const CreateAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::CreateAuthorizer, request); } /** * An Async wrapper for CreateAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAuthorizerAsync(const CreateAuthorizerRequestT& request, const CreateAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateAuthorizer, request, handler, context); } /** *

Creates a billing group.

Requires permission to access the CreateBillingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateBillingGroupOutcome CreateBillingGroup(const Model::CreateBillingGroupRequest& request) const; /** * A Callable wrapper for CreateBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBillingGroupOutcomeCallable CreateBillingGroupCallable(const CreateBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::CreateBillingGroup, request); } /** * An Async wrapper for CreateBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBillingGroupAsync(const CreateBillingGroupRequestT& request, const CreateBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateBillingGroup, request, handler, context); } /** *

Creates an X.509 certificate using the specified certificate signing request. *

Requires permission to access the CreateCertificateFromCsr * action.

The CSR must include a public key that is either an RSA * key with a length of at least 2048 bits or an ECC key from NIST P-256 or NIST * P-384 curves. For supported certificates, consult * Certificate signing algorithms supported by IoT.

*

Reusing the same certificate signing request (CSR) results in a distinct * certificate.

You can create multiple certificates in a batch by * creating a directory, copying multiple .csr files into that * directory, and then specifying that directory on the command line. The following * commands show how to create a batch of certificates given a batch of CSRs. In * the following commands, we assume that a set of CSRs are located inside of the * directory my-csr-directory:

On Linux and OS X, the command is:

* $ ls my-csr-directory/ | xargs -I {} aws iot create-certificate-from-csr * --certificate-signing-request file://my-csr-directory/{}

This * command lists all of the CSRs in my-csr-directory and pipes each CSR file name * to the aws iot create-certificate-from-csr Amazon Web Services CLI * command to create a certificate for the corresponding CSR.

You can also * run the aws iot create-certificate-from-csr part of the command in * parallel to speed up the certificate creation process:

$ ls * my-csr-directory/ | xargs -P 10 -I {} aws iot create-certificate-from-csr * --certificate-signing-request file://my-csr-directory/{}

On * Windows PowerShell, the command to create certificates for all CSRs in * my-csr-directory is:

> ls -Name my-csr-directory | %{aws iot * create-certificate-from-csr --certificate-signing-request * file://my-csr-directory/$_}

On a Windows command prompt, the * command to create certificates for all CSRs in my-csr-directory is:

* > forfiles /p my-csr-directory /c "cmd /c aws iot * create-certificate-from-csr --certificate-signing-request file://@path" *

See Also:

AWS * API Reference

*/ virtual Model::CreateCertificateFromCsrOutcome CreateCertificateFromCsr(const Model::CreateCertificateFromCsrRequest& request) const; /** * A Callable wrapper for CreateCertificateFromCsr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCertificateFromCsrOutcomeCallable CreateCertificateFromCsrCallable(const CreateCertificateFromCsrRequestT& request) const { return SubmitCallable(&IoTClient::CreateCertificateFromCsr, request); } /** * An Async wrapper for CreateCertificateFromCsr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCertificateFromCsrAsync(const CreateCertificateFromCsrRequestT& request, const CreateCertificateFromCsrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateCertificateFromCsr, request, handler, context); } /** *

Use this API to define a Custom Metric published by your devices to Device * Defender.

Requires permission to access the CreateCustomMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomMetricOutcome CreateCustomMetric(const Model::CreateCustomMetricRequest& request) const; /** * A Callable wrapper for CreateCustomMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomMetricOutcomeCallable CreateCustomMetricCallable(const CreateCustomMetricRequestT& request) const { return SubmitCallable(&IoTClient::CreateCustomMetric, request); } /** * An Async wrapper for CreateCustomMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomMetricAsync(const CreateCustomMetricRequestT& request, const CreateCustomMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateCustomMetric, request, handler, context); } /** *

Create a dimension that you can use to limit the scope of a metric used in a * security profile for IoT Device Defender. For example, using a * TOPIC_FILTER dimension, you can narrow down the scope of the metric * only to MQTT topics whose name match the pattern specified in the dimension.

*

Requires permission to access the CreateDimension * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateDimensionOutcome CreateDimension(const Model::CreateDimensionRequest& request) const; /** * A Callable wrapper for CreateDimension that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDimensionOutcomeCallable CreateDimensionCallable(const CreateDimensionRequestT& request) const { return SubmitCallable(&IoTClient::CreateDimension, request); } /** * An Async wrapper for CreateDimension that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDimensionAsync(const CreateDimensionRequestT& request, const CreateDimensionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateDimension, request, handler, context); } /** *

Creates a domain configuration.

Requires permission to access the CreateDomainConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateDomainConfigurationOutcome CreateDomainConfiguration(const Model::CreateDomainConfigurationRequest& request) const; /** * A Callable wrapper for CreateDomainConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDomainConfigurationOutcomeCallable CreateDomainConfigurationCallable(const CreateDomainConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::CreateDomainConfiguration, request); } /** * An Async wrapper for CreateDomainConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDomainConfigurationAsync(const CreateDomainConfigurationRequestT& request, const CreateDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateDomainConfiguration, request, handler, context); } /** *

Creates a dynamic thing group.

Requires permission to access the CreateDynamicThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateDynamicThingGroupOutcome CreateDynamicThingGroup(const Model::CreateDynamicThingGroupRequest& request) const; /** * A Callable wrapper for CreateDynamicThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDynamicThingGroupOutcomeCallable CreateDynamicThingGroupCallable(const CreateDynamicThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::CreateDynamicThingGroup, request); } /** * An Async wrapper for CreateDynamicThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDynamicThingGroupAsync(const CreateDynamicThingGroupRequestT& request, const CreateDynamicThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateDynamicThingGroup, request, handler, context); } /** *

Creates a fleet metric.

Requires permission to access the CreateFleetMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateFleetMetricOutcome CreateFleetMetric(const Model::CreateFleetMetricRequest& request) const; /** * A Callable wrapper for CreateFleetMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFleetMetricOutcomeCallable CreateFleetMetricCallable(const CreateFleetMetricRequestT& request) const { return SubmitCallable(&IoTClient::CreateFleetMetric, request); } /** * An Async wrapper for CreateFleetMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFleetMetricAsync(const CreateFleetMetricRequestT& request, const CreateFleetMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateFleetMetric, request, handler, context); } /** *

Creates a job.

Requires permission to access the CreateJob * action.

See Also:

AWS API * Reference

*/ virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const; /** * A Callable wrapper for CreateJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const { return SubmitCallable(&IoTClient::CreateJob, request); } /** * An Async wrapper for CreateJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateJob, request, handler, context); } /** *

Creates a job template.

Requires permission to access the CreateJobTemplate * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateJobTemplateOutcome CreateJobTemplate(const Model::CreateJobTemplateRequest& request) const; /** * A Callable wrapper for CreateJobTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateJobTemplateOutcomeCallable CreateJobTemplateCallable(const CreateJobTemplateRequestT& request) const { return SubmitCallable(&IoTClient::CreateJobTemplate, request); } /** * An Async wrapper for CreateJobTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateJobTemplateAsync(const CreateJobTemplateRequestT& request, const CreateJobTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateJobTemplate, request, handler, context); } /** *

Creates a 2048-bit RSA key pair and issues an X.509 certificate using the * issued public key. You can also call CreateKeysAndCertificate over * MQTT from a device, for more information, see Provisioning * MQTT API.

Note This is the only time IoT issues the private * key for this certificate, so it is important to keep it in a secure * location.

Requires permission to access the CreateKeysAndCertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateKeysAndCertificateOutcome CreateKeysAndCertificate(const Model::CreateKeysAndCertificateRequest& request) const; /** * A Callable wrapper for CreateKeysAndCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateKeysAndCertificateOutcomeCallable CreateKeysAndCertificateCallable(const CreateKeysAndCertificateRequestT& request) const { return SubmitCallable(&IoTClient::CreateKeysAndCertificate, request); } /** * An Async wrapper for CreateKeysAndCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateKeysAndCertificateAsync(const CreateKeysAndCertificateRequestT& request, const CreateKeysAndCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateKeysAndCertificate, request, handler, context); } /** *

Defines an action that can be applied to audit findings by using * StartAuditMitigationActionsTask. Only certain types of mitigation actions can be * applied to specific check names. For more information, see Mitigation * actions. Each mitigation action can apply only one type of change.

*

Requires permission to access the CreateMitigationAction * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateMitigationActionOutcome CreateMitigationAction(const Model::CreateMitigationActionRequest& request) const; /** * A Callable wrapper for CreateMitigationAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMitigationActionOutcomeCallable CreateMitigationActionCallable(const CreateMitigationActionRequestT& request) const { return SubmitCallable(&IoTClient::CreateMitigationAction, request); } /** * An Async wrapper for CreateMitigationAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMitigationActionAsync(const CreateMitigationActionRequestT& request, const CreateMitigationActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateMitigationAction, request, handler, context); } /** *

Creates an IoT OTA update on a target group of things or groups.

*

Requires permission to access the CreateOTAUpdate * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateOTAUpdateOutcome CreateOTAUpdate(const Model::CreateOTAUpdateRequest& request) const; /** * A Callable wrapper for CreateOTAUpdate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOTAUpdateOutcomeCallable CreateOTAUpdateCallable(const CreateOTAUpdateRequestT& request) const { return SubmitCallable(&IoTClient::CreateOTAUpdate, request); } /** * An Async wrapper for CreateOTAUpdate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOTAUpdateAsync(const CreateOTAUpdateRequestT& request, const CreateOTAUpdateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateOTAUpdate, request, handler, context); } /** *

Creates an IoT software package that can be deployed to your fleet.

*

Requires permission to access the CreatePackage * and GetIndexingConfiguration * actions.

See Also:

AWS * API Reference

*/ virtual Model::CreatePackageOutcome CreatePackage(const Model::CreatePackageRequest& request) const; /** * A Callable wrapper for CreatePackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePackageOutcomeCallable CreatePackageCallable(const CreatePackageRequestT& request) const { return SubmitCallable(&IoTClient::CreatePackage, request); } /** * An Async wrapper for CreatePackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePackageAsync(const CreatePackageRequestT& request, const CreatePackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreatePackage, request, handler, context); } /** *

Creates a new version for an existing IoT software package.

Requires * permission to access the CreatePackageVersion * and GetIndexingConfiguration * actions.

See Also:

AWS * API Reference

*/ virtual Model::CreatePackageVersionOutcome CreatePackageVersion(const Model::CreatePackageVersionRequest& request) const; /** * A Callable wrapper for CreatePackageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePackageVersionOutcomeCallable CreatePackageVersionCallable(const CreatePackageVersionRequestT& request) const { return SubmitCallable(&IoTClient::CreatePackageVersion, request); } /** * An Async wrapper for CreatePackageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePackageVersionAsync(const CreatePackageVersionRequestT& request, const CreatePackageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreatePackageVersion, request, handler, context); } /** *

Creates an IoT policy.

The created policy is the default version for * the policy. This operation creates a policy version with a version identifier of * 1 and sets 1 as the policy's default version.

Requires * permission to access the CreatePolicy * action.

See Also:

AWS * API Reference

*/ virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const; /** * A Callable wrapper for CreatePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const { return SubmitCallable(&IoTClient::CreatePolicy, request); } /** * An Async wrapper for CreatePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreatePolicy, request, handler, context); } /** *

Creates a new version of the specified IoT policy. To update a policy, create * a new policy version. A managed policy can have up to five versions. If the * policy has five versions, you must use DeletePolicyVersion to delete an * existing version before you create a new one.

Optionally, you can set the * new version as the policy's default version. The default version is the * operative version (that is, the version that is in effect for the certificates * to which the policy is attached).

Requires permission to access the CreatePolicyVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::CreatePolicyVersionOutcome CreatePolicyVersion(const Model::CreatePolicyVersionRequest& request) const; /** * A Callable wrapper for CreatePolicyVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePolicyVersionOutcomeCallable CreatePolicyVersionCallable(const CreatePolicyVersionRequestT& request) const { return SubmitCallable(&IoTClient::CreatePolicyVersion, request); } /** * An Async wrapper for CreatePolicyVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePolicyVersionAsync(const CreatePolicyVersionRequestT& request, const CreatePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreatePolicyVersion, request, handler, context); } /** *

Creates a provisioning claim.

Requires permission to access the CreateProvisioningClaim * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateProvisioningClaimOutcome CreateProvisioningClaim(const Model::CreateProvisioningClaimRequest& request) const; /** * A Callable wrapper for CreateProvisioningClaim that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProvisioningClaimOutcomeCallable CreateProvisioningClaimCallable(const CreateProvisioningClaimRequestT& request) const { return SubmitCallable(&IoTClient::CreateProvisioningClaim, request); } /** * An Async wrapper for CreateProvisioningClaim that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProvisioningClaimAsync(const CreateProvisioningClaimRequestT& request, const CreateProvisioningClaimResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateProvisioningClaim, request, handler, context); } /** *

Creates a provisioning template.

Requires permission to access the CreateProvisioningTemplate * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateProvisioningTemplateOutcome CreateProvisioningTemplate(const Model::CreateProvisioningTemplateRequest& request) const; /** * A Callable wrapper for CreateProvisioningTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProvisioningTemplateOutcomeCallable CreateProvisioningTemplateCallable(const CreateProvisioningTemplateRequestT& request) const { return SubmitCallable(&IoTClient::CreateProvisioningTemplate, request); } /** * An Async wrapper for CreateProvisioningTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProvisioningTemplateAsync(const CreateProvisioningTemplateRequestT& request, const CreateProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateProvisioningTemplate, request, handler, context); } /** *

Creates a new version of a provisioning template.

Requires permission * to access the CreateProvisioningTemplateVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateProvisioningTemplateVersionOutcome CreateProvisioningTemplateVersion(const Model::CreateProvisioningTemplateVersionRequest& request) const; /** * A Callable wrapper for CreateProvisioningTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProvisioningTemplateVersionOutcomeCallable CreateProvisioningTemplateVersionCallable(const CreateProvisioningTemplateVersionRequestT& request) const { return SubmitCallable(&IoTClient::CreateProvisioningTemplateVersion, request); } /** * An Async wrapper for CreateProvisioningTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProvisioningTemplateVersionAsync(const CreateProvisioningTemplateVersionRequestT& request, const CreateProvisioningTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateProvisioningTemplateVersion, request, handler, context); } /** *

Creates a role alias.

Requires permission to access the CreateRoleAlias * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateRoleAliasOutcome CreateRoleAlias(const Model::CreateRoleAliasRequest& request) const; /** * A Callable wrapper for CreateRoleAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRoleAliasOutcomeCallable CreateRoleAliasCallable(const CreateRoleAliasRequestT& request) const { return SubmitCallable(&IoTClient::CreateRoleAlias, request); } /** * An Async wrapper for CreateRoleAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRoleAliasAsync(const CreateRoleAliasRequestT& request, const CreateRoleAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateRoleAlias, request, handler, context); } /** *

Creates a scheduled audit that is run at a specified time interval.

*

Requires permission to access the CreateScheduledAudit * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateScheduledAuditOutcome CreateScheduledAudit(const Model::CreateScheduledAuditRequest& request) const; /** * A Callable wrapper for CreateScheduledAudit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateScheduledAuditOutcomeCallable CreateScheduledAuditCallable(const CreateScheduledAuditRequestT& request) const { return SubmitCallable(&IoTClient::CreateScheduledAudit, request); } /** * An Async wrapper for CreateScheduledAudit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateScheduledAuditAsync(const CreateScheduledAuditRequestT& request, const CreateScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateScheduledAudit, request, handler, context); } /** *

Creates a Device Defender security profile.

Requires permission to * access the CreateSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateSecurityProfileOutcome CreateSecurityProfile(const Model::CreateSecurityProfileRequest& request) const; /** * A Callable wrapper for CreateSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSecurityProfileOutcomeCallable CreateSecurityProfileCallable(const CreateSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::CreateSecurityProfile, request); } /** * An Async wrapper for CreateSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSecurityProfileAsync(const CreateSecurityProfileRequestT& request, const CreateSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateSecurityProfile, request, handler, context); } /** *

Creates a stream for delivering one or more large files in chunks over MQTT. * A stream transports data bytes in chunks or blocks packaged as MQTT messages * from a source like S3. You can have one or more files associated with a * stream.

Requires permission to access the CreateStream * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateStreamOutcome CreateStream(const Model::CreateStreamRequest& request) const; /** * A Callable wrapper for CreateStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStreamOutcomeCallable CreateStreamCallable(const CreateStreamRequestT& request) const { return SubmitCallable(&IoTClient::CreateStream, request); } /** * An Async wrapper for CreateStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStreamAsync(const CreateStreamRequestT& request, const CreateStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateStream, request, handler, context); } /** *

Creates a thing record in the registry. If this call is made multiple times * using the same thing name and configuration, the call will succeed. If this call * is made with the same thing name but different configuration a * ResourceAlreadyExistsException is thrown.

This is a * control plane operation. See Authorization * for information about authorizing control plane actions.

Requires * permission to access the CreateThing * action.

See Also:

AWS API * Reference

*/ virtual Model::CreateThingOutcome CreateThing(const Model::CreateThingRequest& request) const; /** * A Callable wrapper for CreateThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateThingOutcomeCallable CreateThingCallable(const CreateThingRequestT& request) const { return SubmitCallable(&IoTClient::CreateThing, request); } /** * An Async wrapper for CreateThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateThingAsync(const CreateThingRequestT& request, const CreateThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateThing, request, handler, context); } /** *

Create a thing group.

This is a control plane operation. See Authorization * for information about authorizing control plane actions.

Requires * permission to access the CreateThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateThingGroupOutcome CreateThingGroup(const Model::CreateThingGroupRequest& request) const; /** * A Callable wrapper for CreateThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateThingGroupOutcomeCallable CreateThingGroupCallable(const CreateThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::CreateThingGroup, request); } /** * An Async wrapper for CreateThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateThingGroupAsync(const CreateThingGroupRequestT& request, const CreateThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateThingGroup, request, handler, context); } /** *

Creates a new thing type.

Requires permission to access the CreateThingType * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateThingTypeOutcome CreateThingType(const Model::CreateThingTypeRequest& request) const; /** * A Callable wrapper for CreateThingType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateThingTypeOutcomeCallable CreateThingTypeCallable(const CreateThingTypeRequestT& request) const { return SubmitCallable(&IoTClient::CreateThingType, request); } /** * An Async wrapper for CreateThingType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateThingTypeAsync(const CreateThingTypeRequestT& request, const CreateThingTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateThingType, request, handler, context); } /** *

Creates a rule. Creating rules is an administrator-level action. Any user who * has permission to create rules will be able to access data processed by the * rule.

Requires permission to access the CreateTopicRule * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateTopicRuleOutcome CreateTopicRule(const Model::CreateTopicRuleRequest& request) const; /** * A Callable wrapper for CreateTopicRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTopicRuleOutcomeCallable CreateTopicRuleCallable(const CreateTopicRuleRequestT& request) const { return SubmitCallable(&IoTClient::CreateTopicRule, request); } /** * An Async wrapper for CreateTopicRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTopicRuleAsync(const CreateTopicRuleRequestT& request, const CreateTopicRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateTopicRule, request, handler, context); } /** *

Creates a topic rule destination. The destination must be confirmed prior to * use.

Requires permission to access the CreateTopicRuleDestination * action.

See Also:

AWS * API Reference

*/ virtual Model::CreateTopicRuleDestinationOutcome CreateTopicRuleDestination(const Model::CreateTopicRuleDestinationRequest& request) const; /** * A Callable wrapper for CreateTopicRuleDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTopicRuleDestinationOutcomeCallable CreateTopicRuleDestinationCallable(const CreateTopicRuleDestinationRequestT& request) const { return SubmitCallable(&IoTClient::CreateTopicRuleDestination, request); } /** * An Async wrapper for CreateTopicRuleDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTopicRuleDestinationAsync(const CreateTopicRuleDestinationRequestT& request, const CreateTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::CreateTopicRuleDestination, request, handler, context); } /** *

Restores the default settings for Device Defender audits for this account. * Any configuration data you entered is deleted and all audit checks are reset to * disabled.

Requires permission to access the DeleteAccountAuditConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccountAuditConfigurationOutcome DeleteAccountAuditConfiguration(const Model::DeleteAccountAuditConfigurationRequest& request) const; /** * A Callable wrapper for DeleteAccountAuditConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccountAuditConfigurationOutcomeCallable DeleteAccountAuditConfigurationCallable(const DeleteAccountAuditConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::DeleteAccountAuditConfiguration, request); } /** * An Async wrapper for DeleteAccountAuditConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccountAuditConfigurationAsync(const DeleteAccountAuditConfigurationRequestT& request, const DeleteAccountAuditConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteAccountAuditConfiguration, request, handler, context); } /** *

Deletes a Device Defender audit suppression.

Requires permission to * access the DeleteAuditSuppression * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAuditSuppressionOutcome DeleteAuditSuppression(const Model::DeleteAuditSuppressionRequest& request) const; /** * A Callable wrapper for DeleteAuditSuppression that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAuditSuppressionOutcomeCallable DeleteAuditSuppressionCallable(const DeleteAuditSuppressionRequestT& request) const { return SubmitCallable(&IoTClient::DeleteAuditSuppression, request); } /** * An Async wrapper for DeleteAuditSuppression that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAuditSuppressionAsync(const DeleteAuditSuppressionRequestT& request, const DeleteAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteAuditSuppression, request, handler, context); } /** *

Deletes an authorizer.

Requires permission to access the DeleteAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAuthorizerOutcome DeleteAuthorizer(const Model::DeleteAuthorizerRequest& request) const; /** * A Callable wrapper for DeleteAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAuthorizerOutcomeCallable DeleteAuthorizerCallable(const DeleteAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::DeleteAuthorizer, request); } /** * An Async wrapper for DeleteAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAuthorizerAsync(const DeleteAuthorizerRequestT& request, const DeleteAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteAuthorizer, request, handler, context); } /** *

Deletes the billing group.

Requires permission to access the DeleteBillingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBillingGroupOutcome DeleteBillingGroup(const Model::DeleteBillingGroupRequest& request) const; /** * A Callable wrapper for DeleteBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBillingGroupOutcomeCallable DeleteBillingGroupCallable(const DeleteBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::DeleteBillingGroup, request); } /** * An Async wrapper for DeleteBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBillingGroupAsync(const DeleteBillingGroupRequestT& request, const DeleteBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteBillingGroup, request, handler, context); } /** *

Deletes a registered CA certificate.

Requires permission to access the * DeleteCACertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCACertificateOutcome DeleteCACertificate(const Model::DeleteCACertificateRequest& request) const; /** * A Callable wrapper for DeleteCACertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCACertificateOutcomeCallable DeleteCACertificateCallable(const DeleteCACertificateRequestT& request) const { return SubmitCallable(&IoTClient::DeleteCACertificate, request); } /** * An Async wrapper for DeleteCACertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCACertificateAsync(const DeleteCACertificateRequestT& request, const DeleteCACertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteCACertificate, request, handler, context); } /** *

Deletes the specified certificate.

A certificate cannot be deleted if * it has a policy or IoT thing attached to it or if its status is set to ACTIVE. * To delete a certificate, first use the DetachPolicy action to detach all * policies. Next, use the UpdateCertificate action to set the certificate * to the INACTIVE status.

Requires permission to access the DeleteCertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest& request) const; /** * A Callable wrapper for DeleteCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const { return SubmitCallable(&IoTClient::DeleteCertificate, request); } /** * An Async wrapper for DeleteCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteCertificate, request, handler, context); } /** *

Deletes a Device Defender detect custom metric.

Requires permission * to access the DeleteCustomMetric * action.

Before you can delete a custom metric, you must first * remove the custom metric from all security profiles it's a part of. The security * profile associated with the custom metric can be found using the ListSecurityProfiles * API with metricName set to your custom metric name.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomMetricOutcome DeleteCustomMetric(const Model::DeleteCustomMetricRequest& request) const; /** * A Callable wrapper for DeleteCustomMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomMetricOutcomeCallable DeleteCustomMetricCallable(const DeleteCustomMetricRequestT& request) const { return SubmitCallable(&IoTClient::DeleteCustomMetric, request); } /** * An Async wrapper for DeleteCustomMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomMetricAsync(const DeleteCustomMetricRequestT& request, const DeleteCustomMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteCustomMetric, request, handler, context); } /** *

Removes the specified dimension from your Amazon Web Services accounts.

*

Requires permission to access the DeleteDimension * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDimensionOutcome DeleteDimension(const Model::DeleteDimensionRequest& request) const; /** * A Callable wrapper for DeleteDimension that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDimensionOutcomeCallable DeleteDimensionCallable(const DeleteDimensionRequestT& request) const { return SubmitCallable(&IoTClient::DeleteDimension, request); } /** * An Async wrapper for DeleteDimension that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDimensionAsync(const DeleteDimensionRequestT& request, const DeleteDimensionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteDimension, request, handler, context); } /** *

Deletes the specified domain configuration.

Requires permission to * access the DeleteDomainConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDomainConfigurationOutcome DeleteDomainConfiguration(const Model::DeleteDomainConfigurationRequest& request) const; /** * A Callable wrapper for DeleteDomainConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDomainConfigurationOutcomeCallable DeleteDomainConfigurationCallable(const DeleteDomainConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::DeleteDomainConfiguration, request); } /** * An Async wrapper for DeleteDomainConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDomainConfigurationAsync(const DeleteDomainConfigurationRequestT& request, const DeleteDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteDomainConfiguration, request, handler, context); } /** *

Deletes a dynamic thing group.

Requires permission to access the DeleteDynamicThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDynamicThingGroupOutcome DeleteDynamicThingGroup(const Model::DeleteDynamicThingGroupRequest& request) const; /** * A Callable wrapper for DeleteDynamicThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDynamicThingGroupOutcomeCallable DeleteDynamicThingGroupCallable(const DeleteDynamicThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::DeleteDynamicThingGroup, request); } /** * An Async wrapper for DeleteDynamicThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDynamicThingGroupAsync(const DeleteDynamicThingGroupRequestT& request, const DeleteDynamicThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteDynamicThingGroup, request, handler, context); } /** *

Deletes the specified fleet metric. Returns successfully with no error if the * deletion is successful or you specify a fleet metric that doesn't exist.

*

Requires permission to access the DeleteFleetMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFleetMetricOutcome DeleteFleetMetric(const Model::DeleteFleetMetricRequest& request) const; /** * A Callable wrapper for DeleteFleetMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFleetMetricOutcomeCallable DeleteFleetMetricCallable(const DeleteFleetMetricRequestT& request) const { return SubmitCallable(&IoTClient::DeleteFleetMetric, request); } /** * An Async wrapper for DeleteFleetMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFleetMetricAsync(const DeleteFleetMetricRequestT& request, const DeleteFleetMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteFleetMetric, request, handler, context); } /** *

Deletes a job and its related job executions.

Deleting a job may take * time, depending on the number of job executions created for the job and various * other factors. While the job is being deleted, the status of the job will be * shown as "DELETION_IN_PROGRESS". Attempting to delete or cancel a job whose * status is already "DELETION_IN_PROGRESS" will result in an error.

Only 10 * jobs may have status "DELETION_IN_PROGRESS" at the same time, or a * LimitExceededException will occur.

Requires permission to access the DeleteJob * action.

See Also:

AWS API * Reference

*/ virtual Model::DeleteJobOutcome DeleteJob(const Model::DeleteJobRequest& request) const; /** * A Callable wrapper for DeleteJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteJobOutcomeCallable DeleteJobCallable(const DeleteJobRequestT& request) const { return SubmitCallable(&IoTClient::DeleteJob, request); } /** * An Async wrapper for DeleteJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteJobAsync(const DeleteJobRequestT& request, const DeleteJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteJob, request, handler, context); } /** *

Deletes a job execution.

Requires permission to access the DeleteJobExecution * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteJobExecutionOutcome DeleteJobExecution(const Model::DeleteJobExecutionRequest& request) const; /** * A Callable wrapper for DeleteJobExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteJobExecutionOutcomeCallable DeleteJobExecutionCallable(const DeleteJobExecutionRequestT& request) const { return SubmitCallable(&IoTClient::DeleteJobExecution, request); } /** * An Async wrapper for DeleteJobExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteJobExecutionAsync(const DeleteJobExecutionRequestT& request, const DeleteJobExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteJobExecution, request, handler, context); } /** *

Deletes the specified job template.

See Also:

AWS * API Reference

*/ virtual Model::DeleteJobTemplateOutcome DeleteJobTemplate(const Model::DeleteJobTemplateRequest& request) const; /** * A Callable wrapper for DeleteJobTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteJobTemplateOutcomeCallable DeleteJobTemplateCallable(const DeleteJobTemplateRequestT& request) const { return SubmitCallable(&IoTClient::DeleteJobTemplate, request); } /** * An Async wrapper for DeleteJobTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteJobTemplateAsync(const DeleteJobTemplateRequestT& request, const DeleteJobTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteJobTemplate, request, handler, context); } /** *

Deletes a defined mitigation action from your Amazon Web Services * accounts.

Requires permission to access the DeleteMitigationAction * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMitigationActionOutcome DeleteMitigationAction(const Model::DeleteMitigationActionRequest& request) const; /** * A Callable wrapper for DeleteMitigationAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMitigationActionOutcomeCallable DeleteMitigationActionCallable(const DeleteMitigationActionRequestT& request) const { return SubmitCallable(&IoTClient::DeleteMitigationAction, request); } /** * An Async wrapper for DeleteMitigationAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMitigationActionAsync(const DeleteMitigationActionRequestT& request, const DeleteMitigationActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteMitigationAction, request, handler, context); } /** *

Delete an OTA update.

Requires permission to access the DeleteOTAUpdate * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOTAUpdateOutcome DeleteOTAUpdate(const Model::DeleteOTAUpdateRequest& request) const; /** * A Callable wrapper for DeleteOTAUpdate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOTAUpdateOutcomeCallable DeleteOTAUpdateCallable(const DeleteOTAUpdateRequestT& request) const { return SubmitCallable(&IoTClient::DeleteOTAUpdate, request); } /** * An Async wrapper for DeleteOTAUpdate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOTAUpdateAsync(const DeleteOTAUpdateRequestT& request, const DeleteOTAUpdateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteOTAUpdate, request, handler, context); } /** *

Deletes a specific version from a software package.

Note: All * package versions must be deleted before deleting the software package.

*

Requires permission to access the DeletePackageVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::DeletePackageOutcome DeletePackage(const Model::DeletePackageRequest& request) const; /** * A Callable wrapper for DeletePackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePackageOutcomeCallable DeletePackageCallable(const DeletePackageRequestT& request) const { return SubmitCallable(&IoTClient::DeletePackage, request); } /** * An Async wrapper for DeletePackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePackageAsync(const DeletePackageRequestT& request, const DeletePackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeletePackage, request, handler, context); } /** *

Deletes a specific version from a software package.

Note: If a * package version is designated as default, you must remove the designation from * the package using the UpdatePackage action.

See Also:

AWS * API Reference

*/ virtual Model::DeletePackageVersionOutcome DeletePackageVersion(const Model::DeletePackageVersionRequest& request) const; /** * A Callable wrapper for DeletePackageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePackageVersionOutcomeCallable DeletePackageVersionCallable(const DeletePackageVersionRequestT& request) const { return SubmitCallable(&IoTClient::DeletePackageVersion, request); } /** * An Async wrapper for DeletePackageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePackageVersionAsync(const DeletePackageVersionRequestT& request, const DeletePackageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeletePackageVersion, request, handler, context); } /** *

Deletes the specified policy.

A policy cannot be deleted if it has * non-default versions or it is attached to any certificate.

To delete a * policy, use the DeletePolicyVersion action to delete all non-default * versions of the policy; use the DetachPolicy action to detach the policy * from any certificate; and then use the DeletePolicy action to delete the * policy.

When a policy is deleted using DeletePolicy, its default version * is deleted with it.

Because of the distributed nature of Amazon * Web Services, it can take up to five minutes after a policy is detached before * it's ready to be deleted.

Requires permission to access the DeletePolicy * action.

See Also:

AWS * API Reference

*/ virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const; /** * A Callable wrapper for DeletePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const { return SubmitCallable(&IoTClient::DeletePolicy, request); } /** * An Async wrapper for DeletePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeletePolicy, request, handler, context); } /** *

Deletes the specified version of the specified policy. You cannot delete the * default version of a policy using this action. To delete the default version of * a policy, use DeletePolicy. To find out which version of a policy is * marked as the default version, use ListPolicyVersions.

Requires * permission to access the DeletePolicyVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::DeletePolicyVersionOutcome DeletePolicyVersion(const Model::DeletePolicyVersionRequest& request) const; /** * A Callable wrapper for DeletePolicyVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePolicyVersionOutcomeCallable DeletePolicyVersionCallable(const DeletePolicyVersionRequestT& request) const { return SubmitCallable(&IoTClient::DeletePolicyVersion, request); } /** * An Async wrapper for DeletePolicyVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePolicyVersionAsync(const DeletePolicyVersionRequestT& request, const DeletePolicyVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeletePolicyVersion, request, handler, context); } /** *

Deletes a provisioning template.

Requires permission to access the DeleteProvisioningTemplate * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProvisioningTemplateOutcome DeleteProvisioningTemplate(const Model::DeleteProvisioningTemplateRequest& request) const; /** * A Callable wrapper for DeleteProvisioningTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProvisioningTemplateOutcomeCallable DeleteProvisioningTemplateCallable(const DeleteProvisioningTemplateRequestT& request) const { return SubmitCallable(&IoTClient::DeleteProvisioningTemplate, request); } /** * An Async wrapper for DeleteProvisioningTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProvisioningTemplateAsync(const DeleteProvisioningTemplateRequestT& request, const DeleteProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteProvisioningTemplate, request, handler, context); } /** *

Deletes a provisioning template version.

Requires permission to access * the DeleteProvisioningTemplateVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProvisioningTemplateVersionOutcome DeleteProvisioningTemplateVersion(const Model::DeleteProvisioningTemplateVersionRequest& request) const; /** * A Callable wrapper for DeleteProvisioningTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProvisioningTemplateVersionOutcomeCallable DeleteProvisioningTemplateVersionCallable(const DeleteProvisioningTemplateVersionRequestT& request) const { return SubmitCallable(&IoTClient::DeleteProvisioningTemplateVersion, request); } /** * An Async wrapper for DeleteProvisioningTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProvisioningTemplateVersionAsync(const DeleteProvisioningTemplateVersionRequestT& request, const DeleteProvisioningTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteProvisioningTemplateVersion, request, handler, context); } /** *

Deletes a CA certificate registration code.

Requires permission to * access the DeleteRegistrationCode * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRegistrationCodeOutcome DeleteRegistrationCode(const Model::DeleteRegistrationCodeRequest& request) const; /** * A Callable wrapper for DeleteRegistrationCode that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRegistrationCodeOutcomeCallable DeleteRegistrationCodeCallable(const DeleteRegistrationCodeRequestT& request) const { return SubmitCallable(&IoTClient::DeleteRegistrationCode, request); } /** * An Async wrapper for DeleteRegistrationCode that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRegistrationCodeAsync(const DeleteRegistrationCodeRequestT& request, const DeleteRegistrationCodeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteRegistrationCode, request, handler, context); } /** *

Deletes a role alias

Requires permission to access the DeleteRoleAlias * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRoleAliasOutcome DeleteRoleAlias(const Model::DeleteRoleAliasRequest& request) const; /** * A Callable wrapper for DeleteRoleAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRoleAliasOutcomeCallable DeleteRoleAliasCallable(const DeleteRoleAliasRequestT& request) const { return SubmitCallable(&IoTClient::DeleteRoleAlias, request); } /** * An Async wrapper for DeleteRoleAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRoleAliasAsync(const DeleteRoleAliasRequestT& request, const DeleteRoleAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteRoleAlias, request, handler, context); } /** *

Deletes a scheduled audit.

Requires permission to access the DeleteScheduledAudit * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteScheduledAuditOutcome DeleteScheduledAudit(const Model::DeleteScheduledAuditRequest& request) const; /** * A Callable wrapper for DeleteScheduledAudit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteScheduledAuditOutcomeCallable DeleteScheduledAuditCallable(const DeleteScheduledAuditRequestT& request) const { return SubmitCallable(&IoTClient::DeleteScheduledAudit, request); } /** * An Async wrapper for DeleteScheduledAudit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteScheduledAuditAsync(const DeleteScheduledAuditRequestT& request, const DeleteScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteScheduledAudit, request, handler, context); } /** *

Deletes a Device Defender security profile.

Requires permission to * access the DeleteSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSecurityProfileOutcome DeleteSecurityProfile(const Model::DeleteSecurityProfileRequest& request) const; /** * A Callable wrapper for DeleteSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSecurityProfileOutcomeCallable DeleteSecurityProfileCallable(const DeleteSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::DeleteSecurityProfile, request); } /** * An Async wrapper for DeleteSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSecurityProfileAsync(const DeleteSecurityProfileRequestT& request, const DeleteSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteSecurityProfile, request, handler, context); } /** *

Deletes a stream.

Requires permission to access the DeleteStream * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStreamOutcome DeleteStream(const Model::DeleteStreamRequest& request) const; /** * A Callable wrapper for DeleteStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStreamOutcomeCallable DeleteStreamCallable(const DeleteStreamRequestT& request) const { return SubmitCallable(&IoTClient::DeleteStream, request); } /** * An Async wrapper for DeleteStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStreamAsync(const DeleteStreamRequestT& request, const DeleteStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteStream, request, handler, context); } /** *

Deletes the specified thing. Returns successfully with no error if the * deletion is successful or you specify a thing that doesn't exist.

*

Requires permission to access the DeleteThing * action.

See Also:

AWS API * Reference

*/ virtual Model::DeleteThingOutcome DeleteThing(const Model::DeleteThingRequest& request) const; /** * A Callable wrapper for DeleteThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteThingOutcomeCallable DeleteThingCallable(const DeleteThingRequestT& request) const { return SubmitCallable(&IoTClient::DeleteThing, request); } /** * An Async wrapper for DeleteThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteThingAsync(const DeleteThingRequestT& request, const DeleteThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteThing, request, handler, context); } /** *

Deletes a thing group.

Requires permission to access the DeleteThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteThingGroupOutcome DeleteThingGroup(const Model::DeleteThingGroupRequest& request) const; /** * A Callable wrapper for DeleteThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteThingGroupOutcomeCallable DeleteThingGroupCallable(const DeleteThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::DeleteThingGroup, request); } /** * An Async wrapper for DeleteThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteThingGroupAsync(const DeleteThingGroupRequestT& request, const DeleteThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteThingGroup, request, handler, context); } /** *

Deletes the specified thing type. You cannot delete a thing type if it has * things associated with it. To delete a thing type, first mark it as deprecated * by calling DeprecateThingType, then remove any associated things by * calling UpdateThing to change the thing type on any associated thing, and * finally use DeleteThingType to delete the thing type.

Requires * permission to access the DeleteThingType * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteThingTypeOutcome DeleteThingType(const Model::DeleteThingTypeRequest& request) const; /** * A Callable wrapper for DeleteThingType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteThingTypeOutcomeCallable DeleteThingTypeCallable(const DeleteThingTypeRequestT& request) const { return SubmitCallable(&IoTClient::DeleteThingType, request); } /** * An Async wrapper for DeleteThingType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteThingTypeAsync(const DeleteThingTypeRequestT& request, const DeleteThingTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteThingType, request, handler, context); } /** *

Deletes the rule.

Requires permission to access the DeleteTopicRule * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTopicRuleOutcome DeleteTopicRule(const Model::DeleteTopicRuleRequest& request) const; /** * A Callable wrapper for DeleteTopicRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTopicRuleOutcomeCallable DeleteTopicRuleCallable(const DeleteTopicRuleRequestT& request) const { return SubmitCallable(&IoTClient::DeleteTopicRule, request); } /** * An Async wrapper for DeleteTopicRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTopicRuleAsync(const DeleteTopicRuleRequestT& request, const DeleteTopicRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteTopicRule, request, handler, context); } /** *

Deletes a topic rule destination.

Requires permission to access the DeleteTopicRuleDestination * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTopicRuleDestinationOutcome DeleteTopicRuleDestination(const Model::DeleteTopicRuleDestinationRequest& request) const; /** * A Callable wrapper for DeleteTopicRuleDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTopicRuleDestinationOutcomeCallable DeleteTopicRuleDestinationCallable(const DeleteTopicRuleDestinationRequestT& request) const { return SubmitCallable(&IoTClient::DeleteTopicRuleDestination, request); } /** * An Async wrapper for DeleteTopicRuleDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTopicRuleDestinationAsync(const DeleteTopicRuleDestinationRequestT& request, const DeleteTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteTopicRuleDestination, request, handler, context); } /** *

Deletes a logging level.

Requires permission to access the DeleteV2LoggingLevel * action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteV2LoggingLevelOutcome DeleteV2LoggingLevel(const Model::DeleteV2LoggingLevelRequest& request) const; /** * A Callable wrapper for DeleteV2LoggingLevel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteV2LoggingLevelOutcomeCallable DeleteV2LoggingLevelCallable(const DeleteV2LoggingLevelRequestT& request) const { return SubmitCallable(&IoTClient::DeleteV2LoggingLevel, request); } /** * An Async wrapper for DeleteV2LoggingLevel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteV2LoggingLevelAsync(const DeleteV2LoggingLevelRequestT& request, const DeleteV2LoggingLevelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeleteV2LoggingLevel, request, handler, context); } /** *

Deprecates a thing type. You can not associate new things with deprecated * thing type.

Requires permission to access the DeprecateThingType * action.

See Also:

AWS * API Reference

*/ virtual Model::DeprecateThingTypeOutcome DeprecateThingType(const Model::DeprecateThingTypeRequest& request) const; /** * A Callable wrapper for DeprecateThingType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeprecateThingTypeOutcomeCallable DeprecateThingTypeCallable(const DeprecateThingTypeRequestT& request) const { return SubmitCallable(&IoTClient::DeprecateThingType, request); } /** * An Async wrapper for DeprecateThingType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeprecateThingTypeAsync(const DeprecateThingTypeRequestT& request, const DeprecateThingTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DeprecateThingType, request, handler, context); } /** *

Gets information about the Device Defender audit settings for this account. * Settings include how audit notifications are sent and which audit checks are * enabled or disabled.

Requires permission to access the DescribeAccountAuditConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountAuditConfigurationOutcome DescribeAccountAuditConfiguration(const Model::DescribeAccountAuditConfigurationRequest& request) const; /** * A Callable wrapper for DescribeAccountAuditConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountAuditConfigurationOutcomeCallable DescribeAccountAuditConfigurationCallable(const DescribeAccountAuditConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::DescribeAccountAuditConfiguration, request); } /** * An Async wrapper for DescribeAccountAuditConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountAuditConfigurationAsync(const DescribeAccountAuditConfigurationRequestT& request, const DescribeAccountAuditConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeAccountAuditConfiguration, request, handler, context); } /** *

Gets information about a single audit finding. Properties include the reason * for noncompliance, the severity of the issue, and the start time when the audit * that returned the finding.

Requires permission to access the DescribeAuditFinding * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAuditFindingOutcome DescribeAuditFinding(const Model::DescribeAuditFindingRequest& request) const; /** * A Callable wrapper for DescribeAuditFinding that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAuditFindingOutcomeCallable DescribeAuditFindingCallable(const DescribeAuditFindingRequestT& request) const { return SubmitCallable(&IoTClient::DescribeAuditFinding, request); } /** * An Async wrapper for DescribeAuditFinding that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAuditFindingAsync(const DescribeAuditFindingRequestT& request, const DescribeAuditFindingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeAuditFinding, request, handler, context); } /** *

Gets information about an audit mitigation task that is used to apply * mitigation actions to a set of audit findings. Properties include the actions * being applied, the audit checks to which they're being applied, the task status, * and aggregated task statistics.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAuditMitigationActionsTaskOutcome DescribeAuditMitigationActionsTask(const Model::DescribeAuditMitigationActionsTaskRequest& request) const; /** * A Callable wrapper for DescribeAuditMitigationActionsTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAuditMitigationActionsTaskOutcomeCallable DescribeAuditMitigationActionsTaskCallable(const DescribeAuditMitigationActionsTaskRequestT& request) const { return SubmitCallable(&IoTClient::DescribeAuditMitigationActionsTask, request); } /** * An Async wrapper for DescribeAuditMitigationActionsTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAuditMitigationActionsTaskAsync(const DescribeAuditMitigationActionsTaskRequestT& request, const DescribeAuditMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeAuditMitigationActionsTask, request, handler, context); } /** *

Gets information about a Device Defender audit suppression.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAuditSuppressionOutcome DescribeAuditSuppression(const Model::DescribeAuditSuppressionRequest& request) const; /** * A Callable wrapper for DescribeAuditSuppression that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAuditSuppressionOutcomeCallable DescribeAuditSuppressionCallable(const DescribeAuditSuppressionRequestT& request) const { return SubmitCallable(&IoTClient::DescribeAuditSuppression, request); } /** * An Async wrapper for DescribeAuditSuppression that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAuditSuppressionAsync(const DescribeAuditSuppressionRequestT& request, const DescribeAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeAuditSuppression, request, handler, context); } /** *

Gets information about a Device Defender audit.

Requires permission to * access the DescribeAuditTask * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAuditTaskOutcome DescribeAuditTask(const Model::DescribeAuditTaskRequest& request) const; /** * A Callable wrapper for DescribeAuditTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAuditTaskOutcomeCallable DescribeAuditTaskCallable(const DescribeAuditTaskRequestT& request) const { return SubmitCallable(&IoTClient::DescribeAuditTask, request); } /** * An Async wrapper for DescribeAuditTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAuditTaskAsync(const DescribeAuditTaskRequestT& request, const DescribeAuditTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeAuditTask, request, handler, context); } /** *

Describes an authorizer.

Requires permission to access the DescribeAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAuthorizerOutcome DescribeAuthorizer(const Model::DescribeAuthorizerRequest& request) const; /** * A Callable wrapper for DescribeAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAuthorizerOutcomeCallable DescribeAuthorizerCallable(const DescribeAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::DescribeAuthorizer, request); } /** * An Async wrapper for DescribeAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAuthorizerAsync(const DescribeAuthorizerRequestT& request, const DescribeAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeAuthorizer, request, handler, context); } /** *

Returns information about a billing group.

Requires permission to * access the DescribeBillingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBillingGroupOutcome DescribeBillingGroup(const Model::DescribeBillingGroupRequest& request) const; /** * A Callable wrapper for DescribeBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBillingGroupOutcomeCallable DescribeBillingGroupCallable(const DescribeBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::DescribeBillingGroup, request); } /** * An Async wrapper for DescribeBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBillingGroupAsync(const DescribeBillingGroupRequestT& request, const DescribeBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeBillingGroup, request, handler, context); } /** *

Describes a registered CA certificate.

Requires permission to access * the DescribeCACertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCACertificateOutcome DescribeCACertificate(const Model::DescribeCACertificateRequest& request) const; /** * A Callable wrapper for DescribeCACertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCACertificateOutcomeCallable DescribeCACertificateCallable(const DescribeCACertificateRequestT& request) const { return SubmitCallable(&IoTClient::DescribeCACertificate, request); } /** * An Async wrapper for DescribeCACertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCACertificateAsync(const DescribeCACertificateRequestT& request, const DescribeCACertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeCACertificate, request, handler, context); } /** *

Gets information about the specified certificate.

Requires permission * to access the DescribeCertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCertificateOutcome DescribeCertificate(const Model::DescribeCertificateRequest& request) const; /** * A Callable wrapper for DescribeCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCertificateOutcomeCallable DescribeCertificateCallable(const DescribeCertificateRequestT& request) const { return SubmitCallable(&IoTClient::DescribeCertificate, request); } /** * An Async wrapper for DescribeCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCertificateAsync(const DescribeCertificateRequestT& request, const DescribeCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeCertificate, request, handler, context); } /** *

Gets information about a Device Defender detect custom metric.

*

Requires permission to access the DescribeCustomMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCustomMetricOutcome DescribeCustomMetric(const Model::DescribeCustomMetricRequest& request) const; /** * A Callable wrapper for DescribeCustomMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomMetricOutcomeCallable DescribeCustomMetricCallable(const DescribeCustomMetricRequestT& request) const { return SubmitCallable(&IoTClient::DescribeCustomMetric, request); } /** * An Async wrapper for DescribeCustomMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomMetricAsync(const DescribeCustomMetricRequestT& request, const DescribeCustomMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeCustomMetric, request, handler, context); } /** *

Describes the default authorizer.

Requires permission to access the DescribeDefaultAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDefaultAuthorizerOutcome DescribeDefaultAuthorizer(const Model::DescribeDefaultAuthorizerRequest& request) const; /** * A Callable wrapper for DescribeDefaultAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDefaultAuthorizerOutcomeCallable DescribeDefaultAuthorizerCallable(const DescribeDefaultAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::DescribeDefaultAuthorizer, request); } /** * An Async wrapper for DescribeDefaultAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDefaultAuthorizerAsync(const DescribeDefaultAuthorizerRequestT& request, const DescribeDefaultAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeDefaultAuthorizer, request, handler, context); } /** *

Gets information about a Device Defender ML Detect mitigation action.

*

Requires permission to access the DescribeDetectMitigationActionsTask * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDetectMitigationActionsTaskOutcome DescribeDetectMitigationActionsTask(const Model::DescribeDetectMitigationActionsTaskRequest& request) const; /** * A Callable wrapper for DescribeDetectMitigationActionsTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDetectMitigationActionsTaskOutcomeCallable DescribeDetectMitigationActionsTaskCallable(const DescribeDetectMitigationActionsTaskRequestT& request) const { return SubmitCallable(&IoTClient::DescribeDetectMitigationActionsTask, request); } /** * An Async wrapper for DescribeDetectMitigationActionsTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDetectMitigationActionsTaskAsync(const DescribeDetectMitigationActionsTaskRequestT& request, const DescribeDetectMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeDetectMitigationActionsTask, request, handler, context); } /** *

Provides details about a dimension that is defined in your Amazon Web * Services accounts.

Requires permission to access the DescribeDimension * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDimensionOutcome DescribeDimension(const Model::DescribeDimensionRequest& request) const; /** * A Callable wrapper for DescribeDimension that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDimensionOutcomeCallable DescribeDimensionCallable(const DescribeDimensionRequestT& request) const { return SubmitCallable(&IoTClient::DescribeDimension, request); } /** * An Async wrapper for DescribeDimension that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDimensionAsync(const DescribeDimensionRequestT& request, const DescribeDimensionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeDimension, request, handler, context); } /** *

Gets summary information about a domain configuration.

Requires * permission to access the DescribeDomainConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDomainConfigurationOutcome DescribeDomainConfiguration(const Model::DescribeDomainConfigurationRequest& request) const; /** * A Callable wrapper for DescribeDomainConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDomainConfigurationOutcomeCallable DescribeDomainConfigurationCallable(const DescribeDomainConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::DescribeDomainConfiguration, request); } /** * An Async wrapper for DescribeDomainConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDomainConfigurationAsync(const DescribeDomainConfigurationRequestT& request, const DescribeDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeDomainConfiguration, request, handler, context); } /** *

Returns a unique endpoint specific to the Amazon Web Services account making * the call.

Requires permission to access the DescribeEndpoint * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointOutcome DescribeEndpoint(const Model::DescribeEndpointRequest& request) const; /** * A Callable wrapper for DescribeEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointOutcomeCallable DescribeEndpointCallable(const DescribeEndpointRequestT& request) const { return SubmitCallable(&IoTClient::DescribeEndpoint, request); } /** * An Async wrapper for DescribeEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointAsync(const DescribeEndpointRequestT& request, const DescribeEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeEndpoint, request, handler, context); } /** *

Describes event configurations.

Requires permission to access the DescribeEventConfigurations * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventConfigurationsOutcome DescribeEventConfigurations(const Model::DescribeEventConfigurationsRequest& request) const; /** * A Callable wrapper for DescribeEventConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventConfigurationsOutcomeCallable DescribeEventConfigurationsCallable(const DescribeEventConfigurationsRequestT& request) const { return SubmitCallable(&IoTClient::DescribeEventConfigurations, request); } /** * An Async wrapper for DescribeEventConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventConfigurationsAsync(const DescribeEventConfigurationsRequestT& request, const DescribeEventConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeEventConfigurations, request, handler, context); } /** *

Gets information about the specified fleet metric.

Requires permission * to access the DescribeFleetMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFleetMetricOutcome DescribeFleetMetric(const Model::DescribeFleetMetricRequest& request) const; /** * A Callable wrapper for DescribeFleetMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFleetMetricOutcomeCallable DescribeFleetMetricCallable(const DescribeFleetMetricRequestT& request) const { return SubmitCallable(&IoTClient::DescribeFleetMetric, request); } /** * An Async wrapper for DescribeFleetMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFleetMetricAsync(const DescribeFleetMetricRequestT& request, const DescribeFleetMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeFleetMetric, request, handler, context); } /** *

Describes a search index.

Requires permission to access the DescribeIndex * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIndexOutcome DescribeIndex(const Model::DescribeIndexRequest& request) const; /** * A Callable wrapper for DescribeIndex that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIndexOutcomeCallable DescribeIndexCallable(const DescribeIndexRequestT& request) const { return SubmitCallable(&IoTClient::DescribeIndex, request); } /** * An Async wrapper for DescribeIndex that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIndexAsync(const DescribeIndexRequestT& request, const DescribeIndexResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeIndex, request, handler, context); } /** *

Describes a job.

Requires permission to access the DescribeJob * action.

See Also:

AWS API * Reference

*/ virtual Model::DescribeJobOutcome DescribeJob(const Model::DescribeJobRequest& request) const; /** * A Callable wrapper for DescribeJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeJobOutcomeCallable DescribeJobCallable(const DescribeJobRequestT& request) const { return SubmitCallable(&IoTClient::DescribeJob, request); } /** * An Async wrapper for DescribeJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeJobAsync(const DescribeJobRequestT& request, const DescribeJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeJob, request, handler, context); } /** *

Describes a job execution.

Requires permission to access the DescribeJobExecution * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeJobExecutionOutcome DescribeJobExecution(const Model::DescribeJobExecutionRequest& request) const; /** * A Callable wrapper for DescribeJobExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeJobExecutionOutcomeCallable DescribeJobExecutionCallable(const DescribeJobExecutionRequestT& request) const { return SubmitCallable(&IoTClient::DescribeJobExecution, request); } /** * An Async wrapper for DescribeJobExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeJobExecutionAsync(const DescribeJobExecutionRequestT& request, const DescribeJobExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeJobExecution, request, handler, context); } /** *

Returns information about a job template.

See Also:

AWS * API Reference

*/ virtual Model::DescribeJobTemplateOutcome DescribeJobTemplate(const Model::DescribeJobTemplateRequest& request) const; /** * A Callable wrapper for DescribeJobTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeJobTemplateOutcomeCallable DescribeJobTemplateCallable(const DescribeJobTemplateRequestT& request) const { return SubmitCallable(&IoTClient::DescribeJobTemplate, request); } /** * An Async wrapper for DescribeJobTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeJobTemplateAsync(const DescribeJobTemplateRequestT& request, const DescribeJobTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeJobTemplate, request, handler, context); } /** *

View details of a managed job template.

See Also:

AWS * API Reference

*/ virtual Model::DescribeManagedJobTemplateOutcome DescribeManagedJobTemplate(const Model::DescribeManagedJobTemplateRequest& request) const; /** * A Callable wrapper for DescribeManagedJobTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeManagedJobTemplateOutcomeCallable DescribeManagedJobTemplateCallable(const DescribeManagedJobTemplateRequestT& request) const { return SubmitCallable(&IoTClient::DescribeManagedJobTemplate, request); } /** * An Async wrapper for DescribeManagedJobTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeManagedJobTemplateAsync(const DescribeManagedJobTemplateRequestT& request, const DescribeManagedJobTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeManagedJobTemplate, request, handler, context); } /** *

Gets information about a mitigation action.

Requires permission to * access the DescribeMitigationAction * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMitigationActionOutcome DescribeMitigationAction(const Model::DescribeMitigationActionRequest& request) const; /** * A Callable wrapper for DescribeMitigationAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMitigationActionOutcomeCallable DescribeMitigationActionCallable(const DescribeMitigationActionRequestT& request) const { return SubmitCallable(&IoTClient::DescribeMitigationAction, request); } /** * An Async wrapper for DescribeMitigationAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMitigationActionAsync(const DescribeMitigationActionRequestT& request, const DescribeMitigationActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeMitigationAction, request, handler, context); } /** *

Returns information about a provisioning template.

Requires permission * to access the DescribeProvisioningTemplate * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeProvisioningTemplateOutcome DescribeProvisioningTemplate(const Model::DescribeProvisioningTemplateRequest& request) const; /** * A Callable wrapper for DescribeProvisioningTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProvisioningTemplateOutcomeCallable DescribeProvisioningTemplateCallable(const DescribeProvisioningTemplateRequestT& request) const { return SubmitCallable(&IoTClient::DescribeProvisioningTemplate, request); } /** * An Async wrapper for DescribeProvisioningTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProvisioningTemplateAsync(const DescribeProvisioningTemplateRequestT& request, const DescribeProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeProvisioningTemplate, request, handler, context); } /** *

Returns information about a provisioning template version.

Requires * permission to access the DescribeProvisioningTemplateVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeProvisioningTemplateVersionOutcome DescribeProvisioningTemplateVersion(const Model::DescribeProvisioningTemplateVersionRequest& request) const; /** * A Callable wrapper for DescribeProvisioningTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProvisioningTemplateVersionOutcomeCallable DescribeProvisioningTemplateVersionCallable(const DescribeProvisioningTemplateVersionRequestT& request) const { return SubmitCallable(&IoTClient::DescribeProvisioningTemplateVersion, request); } /** * An Async wrapper for DescribeProvisioningTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProvisioningTemplateVersionAsync(const DescribeProvisioningTemplateVersionRequestT& request, const DescribeProvisioningTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeProvisioningTemplateVersion, request, handler, context); } /** *

Describes a role alias.

Requires permission to access the DescribeRoleAlias * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeRoleAliasOutcome DescribeRoleAlias(const Model::DescribeRoleAliasRequest& request) const; /** * A Callable wrapper for DescribeRoleAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRoleAliasOutcomeCallable DescribeRoleAliasCallable(const DescribeRoleAliasRequestT& request) const { return SubmitCallable(&IoTClient::DescribeRoleAlias, request); } /** * An Async wrapper for DescribeRoleAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRoleAliasAsync(const DescribeRoleAliasRequestT& request, const DescribeRoleAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeRoleAlias, request, handler, context); } /** *

Gets information about a scheduled audit.

Requires permission to * access the DescribeScheduledAudit * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeScheduledAuditOutcome DescribeScheduledAudit(const Model::DescribeScheduledAuditRequest& request) const; /** * A Callable wrapper for DescribeScheduledAudit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeScheduledAuditOutcomeCallable DescribeScheduledAuditCallable(const DescribeScheduledAuditRequestT& request) const { return SubmitCallable(&IoTClient::DescribeScheduledAudit, request); } /** * An Async wrapper for DescribeScheduledAudit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeScheduledAuditAsync(const DescribeScheduledAuditRequestT& request, const DescribeScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeScheduledAudit, request, handler, context); } /** *

Gets information about a Device Defender security profile.

Requires * permission to access the DescribeSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSecurityProfileOutcome DescribeSecurityProfile(const Model::DescribeSecurityProfileRequest& request) const; /** * A Callable wrapper for DescribeSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSecurityProfileOutcomeCallable DescribeSecurityProfileCallable(const DescribeSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::DescribeSecurityProfile, request); } /** * An Async wrapper for DescribeSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSecurityProfileAsync(const DescribeSecurityProfileRequestT& request, const DescribeSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeSecurityProfile, request, handler, context); } /** *

Gets information about a stream.

Requires permission to access the DescribeStream * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStreamOutcome DescribeStream(const Model::DescribeStreamRequest& request) const; /** * A Callable wrapper for DescribeStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStreamOutcomeCallable DescribeStreamCallable(const DescribeStreamRequestT& request) const { return SubmitCallable(&IoTClient::DescribeStream, request); } /** * An Async wrapper for DescribeStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStreamAsync(const DescribeStreamRequestT& request, const DescribeStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeStream, request, handler, context); } /** *

Gets information about the specified thing.

Requires permission to * access the DescribeThing * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeThingOutcome DescribeThing(const Model::DescribeThingRequest& request) const; /** * A Callable wrapper for DescribeThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThingOutcomeCallable DescribeThingCallable(const DescribeThingRequestT& request) const { return SubmitCallable(&IoTClient::DescribeThing, request); } /** * An Async wrapper for DescribeThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThingAsync(const DescribeThingRequestT& request, const DescribeThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeThing, request, handler, context); } /** *

Describe a thing group.

Requires permission to access the DescribeThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeThingGroupOutcome DescribeThingGroup(const Model::DescribeThingGroupRequest& request) const; /** * A Callable wrapper for DescribeThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThingGroupOutcomeCallable DescribeThingGroupCallable(const DescribeThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::DescribeThingGroup, request); } /** * An Async wrapper for DescribeThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThingGroupAsync(const DescribeThingGroupRequestT& request, const DescribeThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeThingGroup, request, handler, context); } /** *

Describes a bulk thing provisioning task.

Requires permission to * access the DescribeThingRegistrationTask * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeThingRegistrationTaskOutcome DescribeThingRegistrationTask(const Model::DescribeThingRegistrationTaskRequest& request) const; /** * A Callable wrapper for DescribeThingRegistrationTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThingRegistrationTaskOutcomeCallable DescribeThingRegistrationTaskCallable(const DescribeThingRegistrationTaskRequestT& request) const { return SubmitCallable(&IoTClient::DescribeThingRegistrationTask, request); } /** * An Async wrapper for DescribeThingRegistrationTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThingRegistrationTaskAsync(const DescribeThingRegistrationTaskRequestT& request, const DescribeThingRegistrationTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeThingRegistrationTask, request, handler, context); } /** *

Gets information about the specified thing type.

Requires permission * to access the DescribeThingType * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeThingTypeOutcome DescribeThingType(const Model::DescribeThingTypeRequest& request) const; /** * A Callable wrapper for DescribeThingType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThingTypeOutcomeCallable DescribeThingTypeCallable(const DescribeThingTypeRequestT& request) const { return SubmitCallable(&IoTClient::DescribeThingType, request); } /** * An Async wrapper for DescribeThingType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThingTypeAsync(const DescribeThingTypeRequestT& request, const DescribeThingTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DescribeThingType, request, handler, context); } /** *

Detaches a policy from the specified target.

Because of the * distributed nature of Amazon Web Services, it can take up to five minutes after * a policy is detached before it's ready to be deleted.

Requires * permission to access the DetachPolicy * action.

See Also:

AWS * API Reference

*/ virtual Model::DetachPolicyOutcome DetachPolicy(const Model::DetachPolicyRequest& request) const; /** * A Callable wrapper for DetachPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachPolicyOutcomeCallable DetachPolicyCallable(const DetachPolicyRequestT& request) const { return SubmitCallable(&IoTClient::DetachPolicy, request); } /** * An Async wrapper for DetachPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachPolicyAsync(const DetachPolicyRequestT& request, const DetachPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DetachPolicy, request, handler, context); } /** *

Disassociates a Device Defender security profile from a thing group or from * this account.

Requires permission to access the DetachSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::DetachSecurityProfileOutcome DetachSecurityProfile(const Model::DetachSecurityProfileRequest& request) const; /** * A Callable wrapper for DetachSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachSecurityProfileOutcomeCallable DetachSecurityProfileCallable(const DetachSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::DetachSecurityProfile, request); } /** * An Async wrapper for DetachSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachSecurityProfileAsync(const DetachSecurityProfileRequestT& request, const DetachSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DetachSecurityProfile, request, handler, context); } /** *

Detaches the specified principal from the specified thing. A principal can be * X.509 certificates, IAM users, groups, and roles, Amazon Cognito identities or * federated identities.

This call is asynchronous. It might take * several seconds for the detachment to propagate.

Requires * permission to access the DetachThingPrincipal * action.

See Also:

AWS * API Reference

*/ virtual Model::DetachThingPrincipalOutcome DetachThingPrincipal(const Model::DetachThingPrincipalRequest& request) const; /** * A Callable wrapper for DetachThingPrincipal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachThingPrincipalOutcomeCallable DetachThingPrincipalCallable(const DetachThingPrincipalRequestT& request) const { return SubmitCallable(&IoTClient::DetachThingPrincipal, request); } /** * An Async wrapper for DetachThingPrincipal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachThingPrincipalAsync(const DetachThingPrincipalRequestT& request, const DetachThingPrincipalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DetachThingPrincipal, request, handler, context); } /** *

Disables the rule.

Requires permission to access the DisableTopicRule * action.

See Also:

AWS * API Reference

*/ virtual Model::DisableTopicRuleOutcome DisableTopicRule(const Model::DisableTopicRuleRequest& request) const; /** * A Callable wrapper for DisableTopicRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableTopicRuleOutcomeCallable DisableTopicRuleCallable(const DisableTopicRuleRequestT& request) const { return SubmitCallable(&IoTClient::DisableTopicRule, request); } /** * An Async wrapper for DisableTopicRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableTopicRuleAsync(const DisableTopicRuleRequestT& request, const DisableTopicRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::DisableTopicRule, request, handler, context); } /** *

Enables the rule.

Requires permission to access the EnableTopicRule * action.

See Also:

AWS * API Reference

*/ virtual Model::EnableTopicRuleOutcome EnableTopicRule(const Model::EnableTopicRuleRequest& request) const; /** * A Callable wrapper for EnableTopicRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableTopicRuleOutcomeCallable EnableTopicRuleCallable(const EnableTopicRuleRequestT& request) const { return SubmitCallable(&IoTClient::EnableTopicRule, request); } /** * An Async wrapper for EnableTopicRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableTopicRuleAsync(const EnableTopicRuleRequestT& request, const EnableTopicRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::EnableTopicRule, request, handler, context); } /** *

Returns a Device Defender's ML Detect Security Profile training model's * status.

Requires permission to access the GetBehaviorModelTrainingSummaries * action.

See Also:

AWS * API Reference

*/ virtual Model::GetBehaviorModelTrainingSummariesOutcome GetBehaviorModelTrainingSummaries(const Model::GetBehaviorModelTrainingSummariesRequest& request) const; /** * A Callable wrapper for GetBehaviorModelTrainingSummaries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBehaviorModelTrainingSummariesOutcomeCallable GetBehaviorModelTrainingSummariesCallable(const GetBehaviorModelTrainingSummariesRequestT& request) const { return SubmitCallable(&IoTClient::GetBehaviorModelTrainingSummaries, request); } /** * An Async wrapper for GetBehaviorModelTrainingSummaries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBehaviorModelTrainingSummariesAsync(const GetBehaviorModelTrainingSummariesRequestT& request, const GetBehaviorModelTrainingSummariesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetBehaviorModelTrainingSummaries, request, handler, context); } /** *

Aggregates on indexed data with search queries pertaining to particular * fields.

Requires permission to access the GetBucketsAggregation * action.

See Also:

AWS * API Reference

*/ virtual Model::GetBucketsAggregationOutcome GetBucketsAggregation(const Model::GetBucketsAggregationRequest& request) const; /** * A Callable wrapper for GetBucketsAggregation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketsAggregationOutcomeCallable GetBucketsAggregationCallable(const GetBucketsAggregationRequestT& request) const { return SubmitCallable(&IoTClient::GetBucketsAggregation, request); } /** * An Async wrapper for GetBucketsAggregation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketsAggregationAsync(const GetBucketsAggregationRequestT& request, const GetBucketsAggregationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetBucketsAggregation, request, handler, context); } /** *

Returns the approximate count of unique values that match the query.

*

Requires permission to access the GetCardinality * action.

See Also:

AWS * API Reference

*/ virtual Model::GetCardinalityOutcome GetCardinality(const Model::GetCardinalityRequest& request) const; /** * A Callable wrapper for GetCardinality that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCardinalityOutcomeCallable GetCardinalityCallable(const GetCardinalityRequestT& request) const { return SubmitCallable(&IoTClient::GetCardinality, request); } /** * An Async wrapper for GetCardinality that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCardinalityAsync(const GetCardinalityRequestT& request, const GetCardinalityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetCardinality, request, handler, context); } /** *

Gets a list of the policies that have an effect on the authorization behavior * of the specified device when it connects to the IoT device gateway.

*

Requires permission to access the GetEffectivePolicies * action.

See Also:

AWS * API Reference

*/ virtual Model::GetEffectivePoliciesOutcome GetEffectivePolicies(const Model::GetEffectivePoliciesRequest& request) const; /** * A Callable wrapper for GetEffectivePolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEffectivePoliciesOutcomeCallable GetEffectivePoliciesCallable(const GetEffectivePoliciesRequestT& request) const { return SubmitCallable(&IoTClient::GetEffectivePolicies, request); } /** * An Async wrapper for GetEffectivePolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEffectivePoliciesAsync(const GetEffectivePoliciesRequestT& request, const GetEffectivePoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetEffectivePolicies, request, handler, context); } /** *

Gets the indexing configuration.

Requires permission to access the GetIndexingConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::GetIndexingConfigurationOutcome GetIndexingConfiguration(const Model::GetIndexingConfigurationRequest& request) const; /** * A Callable wrapper for GetIndexingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIndexingConfigurationOutcomeCallable GetIndexingConfigurationCallable(const GetIndexingConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::GetIndexingConfiguration, request); } /** * An Async wrapper for GetIndexingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIndexingConfigurationAsync(const GetIndexingConfigurationRequestT& request, const GetIndexingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetIndexingConfiguration, request, handler, context); } /** *

Gets a job document.

Requires permission to access the GetJobDocument * action.

See Also:

AWS * API Reference

*/ virtual Model::GetJobDocumentOutcome GetJobDocument(const Model::GetJobDocumentRequest& request) const; /** * A Callable wrapper for GetJobDocument that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetJobDocumentOutcomeCallable GetJobDocumentCallable(const GetJobDocumentRequestT& request) const { return SubmitCallable(&IoTClient::GetJobDocument, request); } /** * An Async wrapper for GetJobDocument that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetJobDocumentAsync(const GetJobDocumentRequestT& request, const GetJobDocumentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetJobDocument, request, handler, context); } /** *

Gets the logging options.

NOTE: use of this command is not * recommended. Use GetV2LoggingOptions instead.

Requires * permission to access the GetLoggingOptions * action.

See Also:

AWS * API Reference

*/ virtual Model::GetLoggingOptionsOutcome GetLoggingOptions(const Model::GetLoggingOptionsRequest& request) const; /** * A Callable wrapper for GetLoggingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoggingOptionsOutcomeCallable GetLoggingOptionsCallable(const GetLoggingOptionsRequestT& request) const { return SubmitCallable(&IoTClient::GetLoggingOptions, request); } /** * An Async wrapper for GetLoggingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoggingOptionsAsync(const GetLoggingOptionsRequestT& request, const GetLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetLoggingOptions, request, handler, context); } /** *

Gets an OTA update.

Requires permission to access the GetOTAUpdate * action.

See Also:

AWS * API Reference

*/ virtual Model::GetOTAUpdateOutcome GetOTAUpdate(const Model::GetOTAUpdateRequest& request) const; /** * A Callable wrapper for GetOTAUpdate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOTAUpdateOutcomeCallable GetOTAUpdateCallable(const GetOTAUpdateRequestT& request) const { return SubmitCallable(&IoTClient::GetOTAUpdate, request); } /** * An Async wrapper for GetOTAUpdate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOTAUpdateAsync(const GetOTAUpdateRequestT& request, const GetOTAUpdateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetOTAUpdate, request, handler, context); } /** *

Gets information about the specified software package.

Requires * permission to access the GetPackage * action.

See Also:

AWS API * Reference

*/ virtual Model::GetPackageOutcome GetPackage(const Model::GetPackageRequest& request) const; /** * A Callable wrapper for GetPackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPackageOutcomeCallable GetPackageCallable(const GetPackageRequestT& request) const { return SubmitCallable(&IoTClient::GetPackage, request); } /** * An Async wrapper for GetPackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPackageAsync(const GetPackageRequestT& request, const GetPackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetPackage, request, handler, context); } /** *

Gets information about the specified software package's configuration.

*

Requires permission to access the GetPackageConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::GetPackageConfigurationOutcome GetPackageConfiguration(const Model::GetPackageConfigurationRequest& request) const; /** * A Callable wrapper for GetPackageConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPackageConfigurationOutcomeCallable GetPackageConfigurationCallable(const GetPackageConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::GetPackageConfiguration, request); } /** * An Async wrapper for GetPackageConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPackageConfigurationAsync(const GetPackageConfigurationRequestT& request, const GetPackageConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetPackageConfiguration, request, handler, context); } /** *

Gets information about the specified package version.

Requires * permission to access the GetPackageVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::GetPackageVersionOutcome GetPackageVersion(const Model::GetPackageVersionRequest& request) const; /** * A Callable wrapper for GetPackageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPackageVersionOutcomeCallable GetPackageVersionCallable(const GetPackageVersionRequestT& request) const { return SubmitCallable(&IoTClient::GetPackageVersion, request); } /** * An Async wrapper for GetPackageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPackageVersionAsync(const GetPackageVersionRequestT& request, const GetPackageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetPackageVersion, request, handler, context); } /** *

Groups the aggregated values that match the query into percentile groupings. * The default percentile groupings are: 1,5,25,50,75,95,99, although you can * specify your own when you call GetPercentiles. This function * returns a value for each percentile group specified (or the default percentile * groupings). The percentile group "1" contains the aggregated field value that * occurs in approximately one percent of the values that match the query. The * percentile group "5" contains the aggregated field value that occurs in * approximately five percent of the values that match the query, and so on. The * result is an approximation, the more values that match the query, the more * accurate the percentile values.

Requires permission to access the GetPercentiles * action.

See Also:

AWS * API Reference

*/ virtual Model::GetPercentilesOutcome GetPercentiles(const Model::GetPercentilesRequest& request) const; /** * A Callable wrapper for GetPercentiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPercentilesOutcomeCallable GetPercentilesCallable(const GetPercentilesRequestT& request) const { return SubmitCallable(&IoTClient::GetPercentiles, request); } /** * An Async wrapper for GetPercentiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPercentilesAsync(const GetPercentilesRequestT& request, const GetPercentilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetPercentiles, request, handler, context); } /** *

Gets information about the specified policy with the policy document of the * default version.

Requires permission to access the GetPolicy * action.

See Also:

AWS API * Reference

*/ virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request) const; /** * A Callable wrapper for GetPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request) const { return SubmitCallable(&IoTClient::GetPolicy, request); } /** * An Async wrapper for GetPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPolicyAsync(const GetPolicyRequestT& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetPolicy, request, handler, context); } /** *

Gets information about the specified policy version.

Requires * permission to access the GetPolicyVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::GetPolicyVersionOutcome GetPolicyVersion(const Model::GetPolicyVersionRequest& request) const; /** * A Callable wrapper for GetPolicyVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPolicyVersionOutcomeCallable GetPolicyVersionCallable(const GetPolicyVersionRequestT& request) const { return SubmitCallable(&IoTClient::GetPolicyVersion, request); } /** * An Async wrapper for GetPolicyVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPolicyVersionAsync(const GetPolicyVersionRequestT& request, const GetPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetPolicyVersion, request, handler, context); } /** *

Gets a registration code used to register a CA certificate with IoT.

*

Requires permission to access the GetRegistrationCode * action.

See Also:

AWS * API Reference

*/ virtual Model::GetRegistrationCodeOutcome GetRegistrationCode(const Model::GetRegistrationCodeRequest& request) const; /** * A Callable wrapper for GetRegistrationCode that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRegistrationCodeOutcomeCallable GetRegistrationCodeCallable(const GetRegistrationCodeRequestT& request) const { return SubmitCallable(&IoTClient::GetRegistrationCode, request); } /** * An Async wrapper for GetRegistrationCode that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRegistrationCodeAsync(const GetRegistrationCodeRequestT& request, const GetRegistrationCodeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetRegistrationCode, request, handler, context); } /** *

Returns the count, average, sum, minimum, maximum, sum of squares, variance, * and standard deviation for the specified aggregated field. If the aggregation * field is of type String, only the count statistic is returned.

*

Requires permission to access the GetStatistics * action.

See Also:

AWS * API Reference

*/ virtual Model::GetStatisticsOutcome GetStatistics(const Model::GetStatisticsRequest& request) const; /** * A Callable wrapper for GetStatistics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStatisticsOutcomeCallable GetStatisticsCallable(const GetStatisticsRequestT& request) const { return SubmitCallable(&IoTClient::GetStatistics, request); } /** * An Async wrapper for GetStatistics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStatisticsAsync(const GetStatisticsRequestT& request, const GetStatisticsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetStatistics, request, handler, context); } /** *

Gets information about the rule.

Requires permission to access the GetTopicRule * action.

See Also:

AWS * API Reference

*/ virtual Model::GetTopicRuleOutcome GetTopicRule(const Model::GetTopicRuleRequest& request) const; /** * A Callable wrapper for GetTopicRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTopicRuleOutcomeCallable GetTopicRuleCallable(const GetTopicRuleRequestT& request) const { return SubmitCallable(&IoTClient::GetTopicRule, request); } /** * An Async wrapper for GetTopicRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTopicRuleAsync(const GetTopicRuleRequestT& request, const GetTopicRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetTopicRule, request, handler, context); } /** *

Gets information about a topic rule destination.

Requires permission * to access the GetTopicRuleDestination * action.

See Also:

AWS * API Reference

*/ virtual Model::GetTopicRuleDestinationOutcome GetTopicRuleDestination(const Model::GetTopicRuleDestinationRequest& request) const; /** * A Callable wrapper for GetTopicRuleDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTopicRuleDestinationOutcomeCallable GetTopicRuleDestinationCallable(const GetTopicRuleDestinationRequestT& request) const { return SubmitCallable(&IoTClient::GetTopicRuleDestination, request); } /** * An Async wrapper for GetTopicRuleDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTopicRuleDestinationAsync(const GetTopicRuleDestinationRequestT& request, const GetTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetTopicRuleDestination, request, handler, context); } /** *

Gets the fine grained logging options.

Requires permission to access * the GetV2LoggingOptions * action.

See Also:

AWS * API Reference

*/ virtual Model::GetV2LoggingOptionsOutcome GetV2LoggingOptions(const Model::GetV2LoggingOptionsRequest& request) const; /** * A Callable wrapper for GetV2LoggingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetV2LoggingOptionsOutcomeCallable GetV2LoggingOptionsCallable(const GetV2LoggingOptionsRequestT& request) const { return SubmitCallable(&IoTClient::GetV2LoggingOptions, request); } /** * An Async wrapper for GetV2LoggingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetV2LoggingOptionsAsync(const GetV2LoggingOptionsRequestT& request, const GetV2LoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::GetV2LoggingOptions, request, handler, context); } /** *

Lists the active violations for a given Device Defender security profile.

*

Requires permission to access the ListActiveViolations * action.

See Also:

AWS * API Reference

*/ virtual Model::ListActiveViolationsOutcome ListActiveViolations(const Model::ListActiveViolationsRequest& request) const; /** * A Callable wrapper for ListActiveViolations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListActiveViolationsOutcomeCallable ListActiveViolationsCallable(const ListActiveViolationsRequestT& request) const { return SubmitCallable(&IoTClient::ListActiveViolations, request); } /** * An Async wrapper for ListActiveViolations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListActiveViolationsAsync(const ListActiveViolationsRequestT& request, const ListActiveViolationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListActiveViolations, request, handler, context); } /** *

Lists the policies attached to the specified thing group.

Requires * permission to access the ListAttachedPolicies * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAttachedPoliciesOutcome ListAttachedPolicies(const Model::ListAttachedPoliciesRequest& request) const; /** * A Callable wrapper for ListAttachedPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAttachedPoliciesOutcomeCallable ListAttachedPoliciesCallable(const ListAttachedPoliciesRequestT& request) const { return SubmitCallable(&IoTClient::ListAttachedPolicies, request); } /** * An Async wrapper for ListAttachedPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAttachedPoliciesAsync(const ListAttachedPoliciesRequestT& request, const ListAttachedPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAttachedPolicies, request, handler, context); } /** *

Lists the findings (results) of a Device Defender audit or of the audits * performed during a specified time period. (Findings are retained for 90 * days.)

Requires permission to access the ListAuditFindings * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAuditFindingsOutcome ListAuditFindings(const Model::ListAuditFindingsRequest& request) const; /** * A Callable wrapper for ListAuditFindings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAuditFindingsOutcomeCallable ListAuditFindingsCallable(const ListAuditFindingsRequestT& request) const { return SubmitCallable(&IoTClient::ListAuditFindings, request); } /** * An Async wrapper for ListAuditFindings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAuditFindingsAsync(const ListAuditFindingsRequestT& request, const ListAuditFindingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAuditFindings, request, handler, context); } /** *

Gets the status of audit mitigation action tasks that were executed.

*

Requires permission to access the ListAuditMitigationActionsExecutions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAuditMitigationActionsExecutionsOutcome ListAuditMitigationActionsExecutions(const Model::ListAuditMitigationActionsExecutionsRequest& request) const; /** * A Callable wrapper for ListAuditMitigationActionsExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAuditMitigationActionsExecutionsOutcomeCallable ListAuditMitigationActionsExecutionsCallable(const ListAuditMitigationActionsExecutionsRequestT& request) const { return SubmitCallable(&IoTClient::ListAuditMitigationActionsExecutions, request); } /** * An Async wrapper for ListAuditMitigationActionsExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAuditMitigationActionsExecutionsAsync(const ListAuditMitigationActionsExecutionsRequestT& request, const ListAuditMitigationActionsExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAuditMitigationActionsExecutions, request, handler, context); } /** *

Gets a list of audit mitigation action tasks that match the specified * filters.

Requires permission to access the ListAuditMitigationActionsTasks * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAuditMitigationActionsTasksOutcome ListAuditMitigationActionsTasks(const Model::ListAuditMitigationActionsTasksRequest& request) const; /** * A Callable wrapper for ListAuditMitigationActionsTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAuditMitigationActionsTasksOutcomeCallable ListAuditMitigationActionsTasksCallable(const ListAuditMitigationActionsTasksRequestT& request) const { return SubmitCallable(&IoTClient::ListAuditMitigationActionsTasks, request); } /** * An Async wrapper for ListAuditMitigationActionsTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAuditMitigationActionsTasksAsync(const ListAuditMitigationActionsTasksRequestT& request, const ListAuditMitigationActionsTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAuditMitigationActionsTasks, request, handler, context); } /** *

Lists your Device Defender audit listings.

Requires permission to * access the ListAuditSuppressions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAuditSuppressionsOutcome ListAuditSuppressions(const Model::ListAuditSuppressionsRequest& request) const; /** * A Callable wrapper for ListAuditSuppressions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAuditSuppressionsOutcomeCallable ListAuditSuppressionsCallable(const ListAuditSuppressionsRequestT& request) const { return SubmitCallable(&IoTClient::ListAuditSuppressions, request); } /** * An Async wrapper for ListAuditSuppressions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAuditSuppressionsAsync(const ListAuditSuppressionsRequestT& request, const ListAuditSuppressionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAuditSuppressions, request, handler, context); } /** *

Lists the Device Defender audits that have been performed during a given time * period.

Requires permission to access the ListAuditTasks * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAuditTasksOutcome ListAuditTasks(const Model::ListAuditTasksRequest& request) const; /** * A Callable wrapper for ListAuditTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAuditTasksOutcomeCallable ListAuditTasksCallable(const ListAuditTasksRequestT& request) const { return SubmitCallable(&IoTClient::ListAuditTasks, request); } /** * An Async wrapper for ListAuditTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAuditTasksAsync(const ListAuditTasksRequestT& request, const ListAuditTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAuditTasks, request, handler, context); } /** *

Lists the authorizers registered in your account.

Requires permission * to access the ListAuthorizers * action.

See Also:

AWS * API Reference

*/ virtual Model::ListAuthorizersOutcome ListAuthorizers(const Model::ListAuthorizersRequest& request) const; /** * A Callable wrapper for ListAuthorizers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAuthorizersOutcomeCallable ListAuthorizersCallable(const ListAuthorizersRequestT& request) const { return SubmitCallable(&IoTClient::ListAuthorizers, request); } /** * An Async wrapper for ListAuthorizers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAuthorizersAsync(const ListAuthorizersRequestT& request, const ListAuthorizersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListAuthorizers, request, handler, context); } /** *

Lists the billing groups you have created.

Requires permission to * access the ListBillingGroups * action.

See Also:

AWS * API Reference

*/ virtual Model::ListBillingGroupsOutcome ListBillingGroups(const Model::ListBillingGroupsRequest& request) const; /** * A Callable wrapper for ListBillingGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBillingGroupsOutcomeCallable ListBillingGroupsCallable(const ListBillingGroupsRequestT& request) const { return SubmitCallable(&IoTClient::ListBillingGroups, request); } /** * An Async wrapper for ListBillingGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBillingGroupsAsync(const ListBillingGroupsRequestT& request, const ListBillingGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListBillingGroups, request, handler, context); } /** *

Lists the CA certificates registered for your Amazon Web Services * account.

The results are paginated with a default page size of 25. You * can use the returned marker to retrieve additional results.

Requires * permission to access the ListCACertificates * action.

See Also:

AWS * API Reference

*/ virtual Model::ListCACertificatesOutcome ListCACertificates(const Model::ListCACertificatesRequest& request) const; /** * A Callable wrapper for ListCACertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCACertificatesOutcomeCallable ListCACertificatesCallable(const ListCACertificatesRequestT& request) const { return SubmitCallable(&IoTClient::ListCACertificates, request); } /** * An Async wrapper for ListCACertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCACertificatesAsync(const ListCACertificatesRequestT& request, const ListCACertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListCACertificates, request, handler, context); } /** *

Lists the certificates registered in your Amazon Web Services account.

*

The results are paginated with a default page size of 25. You can use the * returned marker to retrieve additional results.

Requires permission to * access the ListCertificates * action.

See Also:

AWS * API Reference

*/ virtual Model::ListCertificatesOutcome ListCertificates(const Model::ListCertificatesRequest& request) const; /** * A Callable wrapper for ListCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCertificatesOutcomeCallable ListCertificatesCallable(const ListCertificatesRequestT& request) const { return SubmitCallable(&IoTClient::ListCertificates, request); } /** * An Async wrapper for ListCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCertificatesAsync(const ListCertificatesRequestT& request, const ListCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListCertificates, request, handler, context); } /** *

List the device certificates signed by the specified CA certificate.

*

Requires permission to access the ListCertificatesByCA * action.

See Also:

AWS * API Reference

*/ virtual Model::ListCertificatesByCAOutcome ListCertificatesByCA(const Model::ListCertificatesByCARequest& request) const; /** * A Callable wrapper for ListCertificatesByCA that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCertificatesByCAOutcomeCallable ListCertificatesByCACallable(const ListCertificatesByCARequestT& request) const { return SubmitCallable(&IoTClient::ListCertificatesByCA, request); } /** * An Async wrapper for ListCertificatesByCA that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCertificatesByCAAsync(const ListCertificatesByCARequestT& request, const ListCertificatesByCAResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListCertificatesByCA, request, handler, context); } /** *

Lists your Device Defender detect custom metrics.

Requires * permission to access the ListCustomMetrics * action.

See Also:

AWS * API Reference

*/ virtual Model::ListCustomMetricsOutcome ListCustomMetrics(const Model::ListCustomMetricsRequest& request) const; /** * A Callable wrapper for ListCustomMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomMetricsOutcomeCallable ListCustomMetricsCallable(const ListCustomMetricsRequestT& request) const { return SubmitCallable(&IoTClient::ListCustomMetrics, request); } /** * An Async wrapper for ListCustomMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomMetricsAsync(const ListCustomMetricsRequestT& request, const ListCustomMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListCustomMetrics, request, handler, context); } /** *

Lists mitigation actions executions for a Device Defender ML Detect Security * Profile.

Requires permission to access the ListDetectMitigationActionsExecutions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListDetectMitigationActionsExecutionsOutcome ListDetectMitigationActionsExecutions(const Model::ListDetectMitigationActionsExecutionsRequest& request) const; /** * A Callable wrapper for ListDetectMitigationActionsExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDetectMitigationActionsExecutionsOutcomeCallable ListDetectMitigationActionsExecutionsCallable(const ListDetectMitigationActionsExecutionsRequestT& request) const { return SubmitCallable(&IoTClient::ListDetectMitigationActionsExecutions, request); } /** * An Async wrapper for ListDetectMitigationActionsExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDetectMitigationActionsExecutionsAsync(const ListDetectMitigationActionsExecutionsRequestT& request, const ListDetectMitigationActionsExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListDetectMitigationActionsExecutions, request, handler, context); } /** *

List of Device Defender ML Detect mitigation actions tasks.

Requires * permission to access the ListDetectMitigationActionsTasks * action.

See Also:

AWS * API Reference

*/ virtual Model::ListDetectMitigationActionsTasksOutcome ListDetectMitigationActionsTasks(const Model::ListDetectMitigationActionsTasksRequest& request) const; /** * A Callable wrapper for ListDetectMitigationActionsTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDetectMitigationActionsTasksOutcomeCallable ListDetectMitigationActionsTasksCallable(const ListDetectMitigationActionsTasksRequestT& request) const { return SubmitCallable(&IoTClient::ListDetectMitigationActionsTasks, request); } /** * An Async wrapper for ListDetectMitigationActionsTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDetectMitigationActionsTasksAsync(const ListDetectMitigationActionsTasksRequestT& request, const ListDetectMitigationActionsTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListDetectMitigationActionsTasks, request, handler, context); } /** *

List the set of dimensions that are defined for your Amazon Web Services * accounts.

Requires permission to access the ListDimensions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListDimensionsOutcome ListDimensions(const Model::ListDimensionsRequest& request) const; /** * A Callable wrapper for ListDimensions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDimensionsOutcomeCallable ListDimensionsCallable(const ListDimensionsRequestT& request) const { return SubmitCallable(&IoTClient::ListDimensions, request); } /** * An Async wrapper for ListDimensions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDimensionsAsync(const ListDimensionsRequestT& request, const ListDimensionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListDimensions, request, handler, context); } /** *

Gets a list of domain configurations for the user. This list is sorted * alphabetically by domain configuration name.

Requires permission to * access the ListDomainConfigurations * action.

See Also:

AWS * API Reference

*/ virtual Model::ListDomainConfigurationsOutcome ListDomainConfigurations(const Model::ListDomainConfigurationsRequest& request) const; /** * A Callable wrapper for ListDomainConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDomainConfigurationsOutcomeCallable ListDomainConfigurationsCallable(const ListDomainConfigurationsRequestT& request) const { return SubmitCallable(&IoTClient::ListDomainConfigurations, request); } /** * An Async wrapper for ListDomainConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDomainConfigurationsAsync(const ListDomainConfigurationsRequestT& request, const ListDomainConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListDomainConfigurations, request, handler, context); } /** *

Lists all your fleet metrics.

Requires permission to access the ListFleetMetrics * action.

See Also:

AWS * API Reference

*/ virtual Model::ListFleetMetricsOutcome ListFleetMetrics(const Model::ListFleetMetricsRequest& request) const; /** * A Callable wrapper for ListFleetMetrics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFleetMetricsOutcomeCallable ListFleetMetricsCallable(const ListFleetMetricsRequestT& request) const { return SubmitCallable(&IoTClient::ListFleetMetrics, request); } /** * An Async wrapper for ListFleetMetrics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFleetMetricsAsync(const ListFleetMetricsRequestT& request, const ListFleetMetricsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListFleetMetrics, request, handler, context); } /** *

Lists the search indices.

Requires permission to access the ListIndices * action.

See Also:

AWS API * Reference

*/ virtual Model::ListIndicesOutcome ListIndices(const Model::ListIndicesRequest& request) const; /** * A Callable wrapper for ListIndices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIndicesOutcomeCallable ListIndicesCallable(const ListIndicesRequestT& request) const { return SubmitCallable(&IoTClient::ListIndices, request); } /** * An Async wrapper for ListIndices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIndicesAsync(const ListIndicesRequestT& request, const ListIndicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListIndices, request, handler, context); } /** *

Lists the job executions for a job.

Requires permission to access the * ListJobExecutionsForJob * action.

See Also:

AWS * API Reference

*/ virtual Model::ListJobExecutionsForJobOutcome ListJobExecutionsForJob(const Model::ListJobExecutionsForJobRequest& request) const; /** * A Callable wrapper for ListJobExecutionsForJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListJobExecutionsForJobOutcomeCallable ListJobExecutionsForJobCallable(const ListJobExecutionsForJobRequestT& request) const { return SubmitCallable(&IoTClient::ListJobExecutionsForJob, request); } /** * An Async wrapper for ListJobExecutionsForJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListJobExecutionsForJobAsync(const ListJobExecutionsForJobRequestT& request, const ListJobExecutionsForJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListJobExecutionsForJob, request, handler, context); } /** *

Lists the job executions for the specified thing.

Requires permission * to access the ListJobExecutionsForThing * action.

See Also:

AWS * API Reference

*/ virtual Model::ListJobExecutionsForThingOutcome ListJobExecutionsForThing(const Model::ListJobExecutionsForThingRequest& request) const; /** * A Callable wrapper for ListJobExecutionsForThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListJobExecutionsForThingOutcomeCallable ListJobExecutionsForThingCallable(const ListJobExecutionsForThingRequestT& request) const { return SubmitCallable(&IoTClient::ListJobExecutionsForThing, request); } /** * An Async wrapper for ListJobExecutionsForThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListJobExecutionsForThingAsync(const ListJobExecutionsForThingRequestT& request, const ListJobExecutionsForThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListJobExecutionsForThing, request, handler, context); } /** *

Returns a list of job templates.

Requires permission to access the ListJobTemplates * action.

See Also:

AWS * API Reference

*/ virtual Model::ListJobTemplatesOutcome ListJobTemplates(const Model::ListJobTemplatesRequest& request) const; /** * A Callable wrapper for ListJobTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListJobTemplatesOutcomeCallable ListJobTemplatesCallable(const ListJobTemplatesRequestT& request) const { return SubmitCallable(&IoTClient::ListJobTemplates, request); } /** * An Async wrapper for ListJobTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListJobTemplatesAsync(const ListJobTemplatesRequestT& request, const ListJobTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListJobTemplates, request, handler, context); } /** *

Lists jobs.

Requires permission to access the ListJobs * action.

See Also:

AWS API * Reference

*/ virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request) const; /** * A Callable wrapper for ListJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request) const { return SubmitCallable(&IoTClient::ListJobs, request); } /** * An Async wrapper for ListJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListJobsAsync(const ListJobsRequestT& request, const ListJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListJobs, request, handler, context); } /** *

Returns a list of managed job templates.

See Also:

AWS * API Reference

*/ virtual Model::ListManagedJobTemplatesOutcome ListManagedJobTemplates(const Model::ListManagedJobTemplatesRequest& request) const; /** * A Callable wrapper for ListManagedJobTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListManagedJobTemplatesOutcomeCallable ListManagedJobTemplatesCallable(const ListManagedJobTemplatesRequestT& request) const { return SubmitCallable(&IoTClient::ListManagedJobTemplates, request); } /** * An Async wrapper for ListManagedJobTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListManagedJobTemplatesAsync(const ListManagedJobTemplatesRequestT& request, const ListManagedJobTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListManagedJobTemplates, request, handler, context); } /** *

Lists the values reported for an IoT Device Defender metric (device-side * metric, cloud-side metric, or custom metric) by the given thing during the * specified time period.

See Also:

AWS * API Reference

*/ virtual Model::ListMetricValuesOutcome ListMetricValues(const Model::ListMetricValuesRequest& request) const; /** * A Callable wrapper for ListMetricValues that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMetricValuesOutcomeCallable ListMetricValuesCallable(const ListMetricValuesRequestT& request) const { return SubmitCallable(&IoTClient::ListMetricValues, request); } /** * An Async wrapper for ListMetricValues that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMetricValuesAsync(const ListMetricValuesRequestT& request, const ListMetricValuesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListMetricValues, request, handler, context); } /** *

Gets a list of all mitigation actions that match the specified filter * criteria.

Requires permission to access the ListMitigationActions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListMitigationActionsOutcome ListMitigationActions(const Model::ListMitigationActionsRequest& request) const; /** * A Callable wrapper for ListMitigationActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMitigationActionsOutcomeCallable ListMitigationActionsCallable(const ListMitigationActionsRequestT& request) const { return SubmitCallable(&IoTClient::ListMitigationActions, request); } /** * An Async wrapper for ListMitigationActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMitigationActionsAsync(const ListMitigationActionsRequestT& request, const ListMitigationActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListMitigationActions, request, handler, context); } /** *

Lists OTA updates.

Requires permission to access the ListOTAUpdates * action.

See Also:

AWS * API Reference

*/ virtual Model::ListOTAUpdatesOutcome ListOTAUpdates(const Model::ListOTAUpdatesRequest& request) const; /** * A Callable wrapper for ListOTAUpdates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOTAUpdatesOutcomeCallable ListOTAUpdatesCallable(const ListOTAUpdatesRequestT& request) const { return SubmitCallable(&IoTClient::ListOTAUpdates, request); } /** * An Async wrapper for ListOTAUpdates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOTAUpdatesAsync(const ListOTAUpdatesRequestT& request, const ListOTAUpdatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListOTAUpdates, request, handler, context); } /** *

Lists certificates that are being transferred but not yet accepted.

*

Requires permission to access the ListOutgoingCertificates * action.

See Also:

AWS * API Reference

*/ virtual Model::ListOutgoingCertificatesOutcome ListOutgoingCertificates(const Model::ListOutgoingCertificatesRequest& request) const; /** * A Callable wrapper for ListOutgoingCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOutgoingCertificatesOutcomeCallable ListOutgoingCertificatesCallable(const ListOutgoingCertificatesRequestT& request) const { return SubmitCallable(&IoTClient::ListOutgoingCertificates, request); } /** * An Async wrapper for ListOutgoingCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOutgoingCertificatesAsync(const ListOutgoingCertificatesRequestT& request, const ListOutgoingCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListOutgoingCertificates, request, handler, context); } /** *

Lists the software package versions associated to the account.

*

Requires permission to access the ListPackageVersions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListPackageVersionsOutcome ListPackageVersions(const Model::ListPackageVersionsRequest& request) const; /** * A Callable wrapper for ListPackageVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPackageVersionsOutcomeCallable ListPackageVersionsCallable(const ListPackageVersionsRequestT& request) const { return SubmitCallable(&IoTClient::ListPackageVersions, request); } /** * An Async wrapper for ListPackageVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPackageVersionsAsync(const ListPackageVersionsRequestT& request, const ListPackageVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListPackageVersions, request, handler, context); } /** *

Lists the software packages associated to the account.

Requires * permission to access the ListPackages * action.

See Also:

AWS * API Reference

*/ virtual Model::ListPackagesOutcome ListPackages(const Model::ListPackagesRequest& request) const; /** * A Callable wrapper for ListPackages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPackagesOutcomeCallable ListPackagesCallable(const ListPackagesRequestT& request) const { return SubmitCallable(&IoTClient::ListPackages, request); } /** * An Async wrapper for ListPackages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPackagesAsync(const ListPackagesRequestT& request, const ListPackagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListPackages, request, handler, context); } /** *

Lists your policies.

Requires permission to access the ListPolicies * action.

See Also:

AWS * API Reference

*/ virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request) const; /** * A Callable wrapper for ListPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request) const { return SubmitCallable(&IoTClient::ListPolicies, request); } /** * An Async wrapper for ListPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPoliciesAsync(const ListPoliciesRequestT& request, const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListPolicies, request, handler, context); } /** *

Lists the versions of the specified policy and identifies the default * version.

Requires permission to access the ListPolicyVersions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListPolicyVersionsOutcome ListPolicyVersions(const Model::ListPolicyVersionsRequest& request) const; /** * A Callable wrapper for ListPolicyVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPolicyVersionsOutcomeCallable ListPolicyVersionsCallable(const ListPolicyVersionsRequestT& request) const { return SubmitCallable(&IoTClient::ListPolicyVersions, request); } /** * An Async wrapper for ListPolicyVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPolicyVersionsAsync(const ListPolicyVersionsRequestT& request, const ListPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListPolicyVersions, request, handler, context); } /** *

Lists the things associated with the specified principal. A principal can be * X.509 certificates, IAM users, groups, and roles, Amazon Cognito identities or * federated identities.

Requires permission to access the ListPrincipalThings * action.

See Also:

AWS * API Reference

*/ virtual Model::ListPrincipalThingsOutcome ListPrincipalThings(const Model::ListPrincipalThingsRequest& request) const; /** * A Callable wrapper for ListPrincipalThings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPrincipalThingsOutcomeCallable ListPrincipalThingsCallable(const ListPrincipalThingsRequestT& request) const { return SubmitCallable(&IoTClient::ListPrincipalThings, request); } /** * An Async wrapper for ListPrincipalThings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPrincipalThingsAsync(const ListPrincipalThingsRequestT& request, const ListPrincipalThingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListPrincipalThings, request, handler, context); } /** *

A list of provisioning template versions.

Requires permission to * access the ListProvisioningTemplateVersions * action.

See Also:

AWS * API Reference

*/ virtual Model::ListProvisioningTemplateVersionsOutcome ListProvisioningTemplateVersions(const Model::ListProvisioningTemplateVersionsRequest& request) const; /** * A Callable wrapper for ListProvisioningTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProvisioningTemplateVersionsOutcomeCallable ListProvisioningTemplateVersionsCallable(const ListProvisioningTemplateVersionsRequestT& request) const { return SubmitCallable(&IoTClient::ListProvisioningTemplateVersions, request); } /** * An Async wrapper for ListProvisioningTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProvisioningTemplateVersionsAsync(const ListProvisioningTemplateVersionsRequestT& request, const ListProvisioningTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListProvisioningTemplateVersions, request, handler, context); } /** *

Lists the provisioning templates in your Amazon Web Services account.

*

Requires permission to access the ListProvisioningTemplates * action.

See Also:

AWS * API Reference

*/ virtual Model::ListProvisioningTemplatesOutcome ListProvisioningTemplates(const Model::ListProvisioningTemplatesRequest& request) const; /** * A Callable wrapper for ListProvisioningTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProvisioningTemplatesOutcomeCallable ListProvisioningTemplatesCallable(const ListProvisioningTemplatesRequestT& request) const { return SubmitCallable(&IoTClient::ListProvisioningTemplates, request); } /** * An Async wrapper for ListProvisioningTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProvisioningTemplatesAsync(const ListProvisioningTemplatesRequestT& request, const ListProvisioningTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListProvisioningTemplates, request, handler, context); } /** *

The related resources of an Audit finding. The following resources can be * returned from calling this API:

  • DEVICE_CERTIFICATE

    • *

  • CA_CERTIFICATE

  • IOT_POLICY

  • *

    COGNITO_IDENTITY_POOL

  • CLIENT_ID

  • *

    ACCOUNT_SETTINGS

  • ROLE_ALIAS

  • IAM_ROLE

    *

  • ISSUER_CERTIFICATE

This API is similar * to DescribeAuditFinding's RelatedResources * but provides pagination and is not limited to 10 resources. When calling DescribeAuditFinding * for the intermediate CA revoked for active device certificates check, * RelatedResources will not be populated. You must use this API, * ListRelatedResourcesForAuditFinding, to list the certificates.

*

See Also:

AWS * API Reference

*/ virtual Model::ListRelatedResourcesForAuditFindingOutcome ListRelatedResourcesForAuditFinding(const Model::ListRelatedResourcesForAuditFindingRequest& request) const; /** * A Callable wrapper for ListRelatedResourcesForAuditFinding that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRelatedResourcesForAuditFindingOutcomeCallable ListRelatedResourcesForAuditFindingCallable(const ListRelatedResourcesForAuditFindingRequestT& request) const { return SubmitCallable(&IoTClient::ListRelatedResourcesForAuditFinding, request); } /** * An Async wrapper for ListRelatedResourcesForAuditFinding that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRelatedResourcesForAuditFindingAsync(const ListRelatedResourcesForAuditFindingRequestT& request, const ListRelatedResourcesForAuditFindingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListRelatedResourcesForAuditFinding, request, handler, context); } /** *

Lists the role aliases registered in your account.

Requires permission * to access the ListRoleAliases * action.

See Also:

AWS * API Reference

*/ virtual Model::ListRoleAliasesOutcome ListRoleAliases(const Model::ListRoleAliasesRequest& request) const; /** * A Callable wrapper for ListRoleAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRoleAliasesOutcomeCallable ListRoleAliasesCallable(const ListRoleAliasesRequestT& request) const { return SubmitCallable(&IoTClient::ListRoleAliases, request); } /** * An Async wrapper for ListRoleAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRoleAliasesAsync(const ListRoleAliasesRequestT& request, const ListRoleAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListRoleAliases, request, handler, context); } /** *

Lists all of your scheduled audits.

Requires permission to access the * ListScheduledAudits * action.

See Also:

AWS * API Reference

*/ virtual Model::ListScheduledAuditsOutcome ListScheduledAudits(const Model::ListScheduledAuditsRequest& request) const; /** * A Callable wrapper for ListScheduledAudits that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListScheduledAuditsOutcomeCallable ListScheduledAuditsCallable(const ListScheduledAuditsRequestT& request) const { return SubmitCallable(&IoTClient::ListScheduledAudits, request); } /** * An Async wrapper for ListScheduledAudits that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListScheduledAuditsAsync(const ListScheduledAuditsRequestT& request, const ListScheduledAuditsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListScheduledAudits, request, handler, context); } /** *

Lists the Device Defender security profiles you've created. You can filter * security profiles by dimension or custom metric.

Requires permission to * access the ListSecurityProfiles * action.

dimensionName and metricName * cannot be used in the same request.

See Also:

AWS * API Reference

*/ virtual Model::ListSecurityProfilesOutcome ListSecurityProfiles(const Model::ListSecurityProfilesRequest& request) const; /** * A Callable wrapper for ListSecurityProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSecurityProfilesOutcomeCallable ListSecurityProfilesCallable(const ListSecurityProfilesRequestT& request) const { return SubmitCallable(&IoTClient::ListSecurityProfiles, request); } /** * An Async wrapper for ListSecurityProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSecurityProfilesAsync(const ListSecurityProfilesRequestT& request, const ListSecurityProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListSecurityProfiles, request, handler, context); } /** *

Lists the Device Defender security profiles attached to a target (thing * group).

Requires permission to access the ListSecurityProfilesForTarget * action.

See Also:

AWS * API Reference

*/ virtual Model::ListSecurityProfilesForTargetOutcome ListSecurityProfilesForTarget(const Model::ListSecurityProfilesForTargetRequest& request) const; /** * A Callable wrapper for ListSecurityProfilesForTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSecurityProfilesForTargetOutcomeCallable ListSecurityProfilesForTargetCallable(const ListSecurityProfilesForTargetRequestT& request) const { return SubmitCallable(&IoTClient::ListSecurityProfilesForTarget, request); } /** * An Async wrapper for ListSecurityProfilesForTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSecurityProfilesForTargetAsync(const ListSecurityProfilesForTargetRequestT& request, const ListSecurityProfilesForTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListSecurityProfilesForTarget, request, handler, context); } /** *

Lists all of the streams in your Amazon Web Services account.

Requires * permission to access the ListStreams * action.

See Also:

AWS API * Reference

*/ virtual Model::ListStreamsOutcome ListStreams(const Model::ListStreamsRequest& request) const; /** * A Callable wrapper for ListStreams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStreamsOutcomeCallable ListStreamsCallable(const ListStreamsRequestT& request) const { return SubmitCallable(&IoTClient::ListStreams, request); } /** * An Async wrapper for ListStreams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStreamsAsync(const ListStreamsRequestT& request, const ListStreamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListStreams, request, handler, context); } /** *

Lists the tags (metadata) you have assigned to the resource.

Requires * permission to access the ListTagsForResource * action.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&IoTClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListTagsForResource, request, handler, context); } /** *

List targets for the specified policy.

Requires permission to access * the ListTargetsForPolicy * action.

See Also:

AWS * API Reference

*/ virtual Model::ListTargetsForPolicyOutcome ListTargetsForPolicy(const Model::ListTargetsForPolicyRequest& request) const; /** * A Callable wrapper for ListTargetsForPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTargetsForPolicyOutcomeCallable ListTargetsForPolicyCallable(const ListTargetsForPolicyRequestT& request) const { return SubmitCallable(&IoTClient::ListTargetsForPolicy, request); } /** * An Async wrapper for ListTargetsForPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTargetsForPolicyAsync(const ListTargetsForPolicyRequestT& request, const ListTargetsForPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListTargetsForPolicy, request, handler, context); } /** *

Lists the targets (thing groups) associated with a given Device Defender * security profile.

Requires permission to access the ListTargetsForSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::ListTargetsForSecurityProfileOutcome ListTargetsForSecurityProfile(const Model::ListTargetsForSecurityProfileRequest& request) const; /** * A Callable wrapper for ListTargetsForSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTargetsForSecurityProfileOutcomeCallable ListTargetsForSecurityProfileCallable(const ListTargetsForSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::ListTargetsForSecurityProfile, request); } /** * An Async wrapper for ListTargetsForSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTargetsForSecurityProfileAsync(const ListTargetsForSecurityProfileRequestT& request, const ListTargetsForSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListTargetsForSecurityProfile, request, handler, context); } /** *

List the thing groups in your account.

Requires permission to access * the ListThingGroups * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingGroupsOutcome ListThingGroups(const Model::ListThingGroupsRequest& request) const; /** * A Callable wrapper for ListThingGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingGroupsOutcomeCallable ListThingGroupsCallable(const ListThingGroupsRequestT& request) const { return SubmitCallable(&IoTClient::ListThingGroups, request); } /** * An Async wrapper for ListThingGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingGroupsAsync(const ListThingGroupsRequestT& request, const ListThingGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingGroups, request, handler, context); } /** *

List the thing groups to which the specified thing belongs.

Requires * permission to access the ListThingGroupsForThing * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingGroupsForThingOutcome ListThingGroupsForThing(const Model::ListThingGroupsForThingRequest& request) const; /** * A Callable wrapper for ListThingGroupsForThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingGroupsForThingOutcomeCallable ListThingGroupsForThingCallable(const ListThingGroupsForThingRequestT& request) const { return SubmitCallable(&IoTClient::ListThingGroupsForThing, request); } /** * An Async wrapper for ListThingGroupsForThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingGroupsForThingAsync(const ListThingGroupsForThingRequestT& request, const ListThingGroupsForThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingGroupsForThing, request, handler, context); } /** *

Lists the principals associated with the specified thing. A principal can be * X.509 certificates, IAM users, groups, and roles, Amazon Cognito identities or * federated identities.

Requires permission to access the ListThingPrincipals * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingPrincipalsOutcome ListThingPrincipals(const Model::ListThingPrincipalsRequest& request) const; /** * A Callable wrapper for ListThingPrincipals that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingPrincipalsOutcomeCallable ListThingPrincipalsCallable(const ListThingPrincipalsRequestT& request) const { return SubmitCallable(&IoTClient::ListThingPrincipals, request); } /** * An Async wrapper for ListThingPrincipals that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingPrincipalsAsync(const ListThingPrincipalsRequestT& request, const ListThingPrincipalsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingPrincipals, request, handler, context); } /** *

Information about the thing registration tasks.

See Also:

AWS * API Reference

*/ virtual Model::ListThingRegistrationTaskReportsOutcome ListThingRegistrationTaskReports(const Model::ListThingRegistrationTaskReportsRequest& request) const; /** * A Callable wrapper for ListThingRegistrationTaskReports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingRegistrationTaskReportsOutcomeCallable ListThingRegistrationTaskReportsCallable(const ListThingRegistrationTaskReportsRequestT& request) const { return SubmitCallable(&IoTClient::ListThingRegistrationTaskReports, request); } /** * An Async wrapper for ListThingRegistrationTaskReports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingRegistrationTaskReportsAsync(const ListThingRegistrationTaskReportsRequestT& request, const ListThingRegistrationTaskReportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingRegistrationTaskReports, request, handler, context); } /** *

List bulk thing provisioning tasks.

Requires permission to access the * ListThingRegistrationTasks * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingRegistrationTasksOutcome ListThingRegistrationTasks(const Model::ListThingRegistrationTasksRequest& request) const; /** * A Callable wrapper for ListThingRegistrationTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingRegistrationTasksOutcomeCallable ListThingRegistrationTasksCallable(const ListThingRegistrationTasksRequestT& request) const { return SubmitCallable(&IoTClient::ListThingRegistrationTasks, request); } /** * An Async wrapper for ListThingRegistrationTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingRegistrationTasksAsync(const ListThingRegistrationTasksRequestT& request, const ListThingRegistrationTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingRegistrationTasks, request, handler, context); } /** *

Lists the existing thing types.

Requires permission to access the ListThingTypes * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingTypesOutcome ListThingTypes(const Model::ListThingTypesRequest& request) const; /** * A Callable wrapper for ListThingTypes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingTypesOutcomeCallable ListThingTypesCallable(const ListThingTypesRequestT& request) const { return SubmitCallable(&IoTClient::ListThingTypes, request); } /** * An Async wrapper for ListThingTypes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingTypesAsync(const ListThingTypesRequestT& request, const ListThingTypesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingTypes, request, handler, context); } /** *

Lists your things. Use the attributeName and attributeValue * parameters to filter your things. For example, calling ListThings * with attributeName=Color and attributeValue=Red retrieves all things in the * registry that contain an attribute Color with the value Red. For * more information, see List * Things from the Amazon Web Services IoT Core Developer Guide.

*

Requires permission to access the ListThings * action.

You will not be charged for calling this API if an * Access denied error is returned. You will also not be charged if no * attributes or pagination token was provided in request and no pagination token * and no results were returned.

See Also:

AWS API * Reference

*/ virtual Model::ListThingsOutcome ListThings(const Model::ListThingsRequest& request) const; /** * A Callable wrapper for ListThings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingsOutcomeCallable ListThingsCallable(const ListThingsRequestT& request) const { return SubmitCallable(&IoTClient::ListThings, request); } /** * An Async wrapper for ListThings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingsAsync(const ListThingsRequestT& request, const ListThingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThings, request, handler, context); } /** *

Lists the things you have added to the given billing group.

Requires * permission to access the ListThingsInBillingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingsInBillingGroupOutcome ListThingsInBillingGroup(const Model::ListThingsInBillingGroupRequest& request) const; /** * A Callable wrapper for ListThingsInBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingsInBillingGroupOutcomeCallable ListThingsInBillingGroupCallable(const ListThingsInBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::ListThingsInBillingGroup, request); } /** * An Async wrapper for ListThingsInBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingsInBillingGroupAsync(const ListThingsInBillingGroupRequestT& request, const ListThingsInBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingsInBillingGroup, request, handler, context); } /** *

Lists the things in the specified group.

Requires permission to access * the ListThingsInThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::ListThingsInThingGroupOutcome ListThingsInThingGroup(const Model::ListThingsInThingGroupRequest& request) const; /** * A Callable wrapper for ListThingsInThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThingsInThingGroupOutcomeCallable ListThingsInThingGroupCallable(const ListThingsInThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::ListThingsInThingGroup, request); } /** * An Async wrapper for ListThingsInThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThingsInThingGroupAsync(const ListThingsInThingGroupRequestT& request, const ListThingsInThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListThingsInThingGroup, request, handler, context); } /** *

Lists all the topic rule destinations in your Amazon Web Services * account.

Requires permission to access the ListTopicRuleDestinations * action.

See Also:

AWS * API Reference

*/ virtual Model::ListTopicRuleDestinationsOutcome ListTopicRuleDestinations(const Model::ListTopicRuleDestinationsRequest& request) const; /** * A Callable wrapper for ListTopicRuleDestinations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTopicRuleDestinationsOutcomeCallable ListTopicRuleDestinationsCallable(const ListTopicRuleDestinationsRequestT& request) const { return SubmitCallable(&IoTClient::ListTopicRuleDestinations, request); } /** * An Async wrapper for ListTopicRuleDestinations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTopicRuleDestinationsAsync(const ListTopicRuleDestinationsRequestT& request, const ListTopicRuleDestinationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListTopicRuleDestinations, request, handler, context); } /** *

Lists the rules for the specific topic.

Requires permission to access * the ListTopicRules * action.

See Also:

AWS * API Reference

*/ virtual Model::ListTopicRulesOutcome ListTopicRules(const Model::ListTopicRulesRequest& request) const; /** * A Callable wrapper for ListTopicRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTopicRulesOutcomeCallable ListTopicRulesCallable(const ListTopicRulesRequestT& request) const { return SubmitCallable(&IoTClient::ListTopicRules, request); } /** * An Async wrapper for ListTopicRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTopicRulesAsync(const ListTopicRulesRequestT& request, const ListTopicRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListTopicRules, request, handler, context); } /** *

Lists logging levels.

Requires permission to access the ListV2LoggingLevels * action.

See Also:

AWS * API Reference

*/ virtual Model::ListV2LoggingLevelsOutcome ListV2LoggingLevels(const Model::ListV2LoggingLevelsRequest& request) const; /** * A Callable wrapper for ListV2LoggingLevels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListV2LoggingLevelsOutcomeCallable ListV2LoggingLevelsCallable(const ListV2LoggingLevelsRequestT& request) const { return SubmitCallable(&IoTClient::ListV2LoggingLevels, request); } /** * An Async wrapper for ListV2LoggingLevels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListV2LoggingLevelsAsync(const ListV2LoggingLevelsRequestT& request, const ListV2LoggingLevelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListV2LoggingLevels, request, handler, context); } /** *

Lists the Device Defender security profile violations discovered during the * given time period. You can use filters to limit the results to those alerts * issued for a particular security profile, behavior, or thing (device).

*

Requires permission to access the ListViolationEvents * action.

See Also:

AWS * API Reference

*/ virtual Model::ListViolationEventsOutcome ListViolationEvents(const Model::ListViolationEventsRequest& request) const; /** * A Callable wrapper for ListViolationEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListViolationEventsOutcomeCallable ListViolationEventsCallable(const ListViolationEventsRequestT& request) const { return SubmitCallable(&IoTClient::ListViolationEvents, request); } /** * An Async wrapper for ListViolationEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListViolationEventsAsync(const ListViolationEventsRequestT& request, const ListViolationEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ListViolationEvents, request, handler, context); } /** *

Set a verification state and provide a description of that verification state * on a violation (detect alarm).

See Also:

AWS * API Reference

*/ virtual Model::PutVerificationStateOnViolationOutcome PutVerificationStateOnViolation(const Model::PutVerificationStateOnViolationRequest& request) const; /** * A Callable wrapper for PutVerificationStateOnViolation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVerificationStateOnViolationOutcomeCallable PutVerificationStateOnViolationCallable(const PutVerificationStateOnViolationRequestT& request) const { return SubmitCallable(&IoTClient::PutVerificationStateOnViolation, request); } /** * An Async wrapper for PutVerificationStateOnViolation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVerificationStateOnViolationAsync(const PutVerificationStateOnViolationRequestT& request, const PutVerificationStateOnViolationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::PutVerificationStateOnViolation, request, handler, context); } /** *

Registers a CA certificate with Amazon Web Services IoT Core. There is no * limit to the number of CA certificates you can register in your Amazon Web * Services account. You can register up to 10 CA certificates with the same * CA subject field per Amazon Web Services account.

Requires * permission to access the RegisterCACertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::RegisterCACertificateOutcome RegisterCACertificate(const Model::RegisterCACertificateRequest& request) const; /** * A Callable wrapper for RegisterCACertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterCACertificateOutcomeCallable RegisterCACertificateCallable(const RegisterCACertificateRequestT& request) const { return SubmitCallable(&IoTClient::RegisterCACertificate, request); } /** * An Async wrapper for RegisterCACertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterCACertificateAsync(const RegisterCACertificateRequestT& request, const RegisterCACertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RegisterCACertificate, request, handler, context); } /** *

Registers a device certificate with IoT in the same certificate * mode as the signing CA. If you have more than one CA certificate that has * the same subject field, you must specify the CA certificate that was used to * sign the device certificate being registered.

Requires permission to * access the RegisterCertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::RegisterCertificateOutcome RegisterCertificate(const Model::RegisterCertificateRequest& request) const; /** * A Callable wrapper for RegisterCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterCertificateOutcomeCallable RegisterCertificateCallable(const RegisterCertificateRequestT& request) const { return SubmitCallable(&IoTClient::RegisterCertificate, request); } /** * An Async wrapper for RegisterCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterCertificateAsync(const RegisterCertificateRequestT& request, const RegisterCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RegisterCertificate, request, handler, context); } /** *

Register a certificate that does not have a certificate authority (CA). For * supported certificates, consult * Certificate signing algorithms supported by IoT.

See Also:

* AWS * API Reference

*/ virtual Model::RegisterCertificateWithoutCAOutcome RegisterCertificateWithoutCA(const Model::RegisterCertificateWithoutCARequest& request) const; /** * A Callable wrapper for RegisterCertificateWithoutCA that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterCertificateWithoutCAOutcomeCallable RegisterCertificateWithoutCACallable(const RegisterCertificateWithoutCARequestT& request) const { return SubmitCallable(&IoTClient::RegisterCertificateWithoutCA, request); } /** * An Async wrapper for RegisterCertificateWithoutCA that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterCertificateWithoutCAAsync(const RegisterCertificateWithoutCARequestT& request, const RegisterCertificateWithoutCAResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RegisterCertificateWithoutCA, request, handler, context); } /** *

Provisions a thing in the device registry. RegisterThing calls other IoT * control plane APIs. These calls might exceed your account level * IoT Throttling Limits and cause throttle errors. Please contact Amazon Web Services Customer * Support to raise your throttling limits if necessary.

Requires * permission to access the RegisterThing * action.

See Also:

AWS * API Reference

*/ virtual Model::RegisterThingOutcome RegisterThing(const Model::RegisterThingRequest& request) const; /** * A Callable wrapper for RegisterThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterThingOutcomeCallable RegisterThingCallable(const RegisterThingRequestT& request) const { return SubmitCallable(&IoTClient::RegisterThing, request); } /** * An Async wrapper for RegisterThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterThingAsync(const RegisterThingRequestT& request, const RegisterThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RegisterThing, request, handler, context); } /** *

Rejects a pending certificate transfer. After IoT rejects a certificate * transfer, the certificate status changes from PENDING_TRANSFER to * INACTIVE.

To check for pending certificate transfers, call * ListCertificates to enumerate your certificates.

This operation * can only be called by the transfer destination. After it is called, the * certificate will be returned to the source's account in the INACTIVE state.

*

Requires permission to access the RejectCertificateTransfer * action.

See Also:

AWS * API Reference

*/ virtual Model::RejectCertificateTransferOutcome RejectCertificateTransfer(const Model::RejectCertificateTransferRequest& request) const; /** * A Callable wrapper for RejectCertificateTransfer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectCertificateTransferOutcomeCallable RejectCertificateTransferCallable(const RejectCertificateTransferRequestT& request) const { return SubmitCallable(&IoTClient::RejectCertificateTransfer, request); } /** * An Async wrapper for RejectCertificateTransfer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectCertificateTransferAsync(const RejectCertificateTransferRequestT& request, const RejectCertificateTransferResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RejectCertificateTransfer, request, handler, context); } /** *

Removes the given thing from the billing group.

Requires permission to * access the RemoveThingFromBillingGroup * action.

This call is asynchronous. It might take several seconds * for the detachment to propagate.

See Also:

AWS * API Reference

*/ virtual Model::RemoveThingFromBillingGroupOutcome RemoveThingFromBillingGroup(const Model::RemoveThingFromBillingGroupRequest& request) const; /** * A Callable wrapper for RemoveThingFromBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveThingFromBillingGroupOutcomeCallable RemoveThingFromBillingGroupCallable(const RemoveThingFromBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::RemoveThingFromBillingGroup, request); } /** * An Async wrapper for RemoveThingFromBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveThingFromBillingGroupAsync(const RemoveThingFromBillingGroupRequestT& request, const RemoveThingFromBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RemoveThingFromBillingGroup, request, handler, context); } /** *

Remove the specified thing from the specified group.

You must specify * either a thingGroupArn or a thingGroupName to identify * the thing group and either a thingArn or a thingName * to identify the thing to remove from the thing group.

Requires * permission to access the RemoveThingFromThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::RemoveThingFromThingGroupOutcome RemoveThingFromThingGroup(const Model::RemoveThingFromThingGroupRequest& request) const; /** * A Callable wrapper for RemoveThingFromThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveThingFromThingGroupOutcomeCallable RemoveThingFromThingGroupCallable(const RemoveThingFromThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::RemoveThingFromThingGroup, request); } /** * An Async wrapper for RemoveThingFromThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveThingFromThingGroupAsync(const RemoveThingFromThingGroupRequestT& request, const RemoveThingFromThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::RemoveThingFromThingGroup, request, handler, context); } /** *

Replaces the rule. You must specify all parameters for the new rule. Creating * rules is an administrator-level action. Any user who has permission to create * rules will be able to access data processed by the rule.

Requires * permission to access the ReplaceTopicRule * action.

See Also:

AWS * API Reference

*/ virtual Model::ReplaceTopicRuleOutcome ReplaceTopicRule(const Model::ReplaceTopicRuleRequest& request) const; /** * A Callable wrapper for ReplaceTopicRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReplaceTopicRuleOutcomeCallable ReplaceTopicRuleCallable(const ReplaceTopicRuleRequestT& request) const { return SubmitCallable(&IoTClient::ReplaceTopicRule, request); } /** * An Async wrapper for ReplaceTopicRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReplaceTopicRuleAsync(const ReplaceTopicRuleRequestT& request, const ReplaceTopicRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ReplaceTopicRule, request, handler, context); } /** *

The query search index.

Requires permission to access the SearchIndex * action.

See Also:

AWS API * Reference

*/ virtual Model::SearchIndexOutcome SearchIndex(const Model::SearchIndexRequest& request) const; /** * A Callable wrapper for SearchIndex that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchIndexOutcomeCallable SearchIndexCallable(const SearchIndexRequestT& request) const { return SubmitCallable(&IoTClient::SearchIndex, request); } /** * An Async wrapper for SearchIndex that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchIndexAsync(const SearchIndexRequestT& request, const SearchIndexResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::SearchIndex, request, handler, context); } /** *

Sets the default authorizer. This will be used if a websocket connection is * made without specifying an authorizer.

Requires permission to access the * SetDefaultAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::SetDefaultAuthorizerOutcome SetDefaultAuthorizer(const Model::SetDefaultAuthorizerRequest& request) const; /** * A Callable wrapper for SetDefaultAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetDefaultAuthorizerOutcomeCallable SetDefaultAuthorizerCallable(const SetDefaultAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::SetDefaultAuthorizer, request); } /** * An Async wrapper for SetDefaultAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetDefaultAuthorizerAsync(const SetDefaultAuthorizerRequestT& request, const SetDefaultAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::SetDefaultAuthorizer, request, handler, context); } /** *

Sets the specified version of the specified policy as the policy's default * (operative) version. This action affects all certificates to which the policy is * attached. To list the principals the policy is attached to, use the * ListPrincipalPolicies action.

Requires permission to access the SetDefaultPolicyVersion * action.

See Also:

AWS * API Reference

*/ virtual Model::SetDefaultPolicyVersionOutcome SetDefaultPolicyVersion(const Model::SetDefaultPolicyVersionRequest& request) const; /** * A Callable wrapper for SetDefaultPolicyVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetDefaultPolicyVersionOutcomeCallable SetDefaultPolicyVersionCallable(const SetDefaultPolicyVersionRequestT& request) const { return SubmitCallable(&IoTClient::SetDefaultPolicyVersion, request); } /** * An Async wrapper for SetDefaultPolicyVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetDefaultPolicyVersionAsync(const SetDefaultPolicyVersionRequestT& request, const SetDefaultPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::SetDefaultPolicyVersion, request, handler, context); } /** *

Sets the logging options.

NOTE: use of this command is not * recommended. Use SetV2LoggingOptions instead.

Requires * permission to access the SetLoggingOptions * action.

See Also:

AWS * API Reference

*/ virtual Model::SetLoggingOptionsOutcome SetLoggingOptions(const Model::SetLoggingOptionsRequest& request) const; /** * A Callable wrapper for SetLoggingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetLoggingOptionsOutcomeCallable SetLoggingOptionsCallable(const SetLoggingOptionsRequestT& request) const { return SubmitCallable(&IoTClient::SetLoggingOptions, request); } /** * An Async wrapper for SetLoggingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetLoggingOptionsAsync(const SetLoggingOptionsRequestT& request, const SetLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::SetLoggingOptions, request, handler, context); } /** *

Sets the logging level.

Requires permission to access the SetV2LoggingLevel * action.

See Also:

AWS * API Reference

*/ virtual Model::SetV2LoggingLevelOutcome SetV2LoggingLevel(const Model::SetV2LoggingLevelRequest& request) const; /** * A Callable wrapper for SetV2LoggingLevel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetV2LoggingLevelOutcomeCallable SetV2LoggingLevelCallable(const SetV2LoggingLevelRequestT& request) const { return SubmitCallable(&IoTClient::SetV2LoggingLevel, request); } /** * An Async wrapper for SetV2LoggingLevel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetV2LoggingLevelAsync(const SetV2LoggingLevelRequestT& request, const SetV2LoggingLevelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::SetV2LoggingLevel, request, handler, context); } /** *

Sets the logging options for the V2 logging service.

Requires * permission to access the SetV2LoggingOptions * action.

See Also:

AWS * API Reference

*/ virtual Model::SetV2LoggingOptionsOutcome SetV2LoggingOptions(const Model::SetV2LoggingOptionsRequest& request) const; /** * A Callable wrapper for SetV2LoggingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetV2LoggingOptionsOutcomeCallable SetV2LoggingOptionsCallable(const SetV2LoggingOptionsRequestT& request) const { return SubmitCallable(&IoTClient::SetV2LoggingOptions, request); } /** * An Async wrapper for SetV2LoggingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetV2LoggingOptionsAsync(const SetV2LoggingOptionsRequestT& request, const SetV2LoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::SetV2LoggingOptions, request, handler, context); } /** *

Starts a task that applies a set of mitigation actions to the specified * target.

Requires permission to access the StartAuditMitigationActionsTask * action.

See Also:

AWS * API Reference

*/ virtual Model::StartAuditMitigationActionsTaskOutcome StartAuditMitigationActionsTask(const Model::StartAuditMitigationActionsTaskRequest& request) const; /** * A Callable wrapper for StartAuditMitigationActionsTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAuditMitigationActionsTaskOutcomeCallable StartAuditMitigationActionsTaskCallable(const StartAuditMitigationActionsTaskRequestT& request) const { return SubmitCallable(&IoTClient::StartAuditMitigationActionsTask, request); } /** * An Async wrapper for StartAuditMitigationActionsTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAuditMitigationActionsTaskAsync(const StartAuditMitigationActionsTaskRequestT& request, const StartAuditMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::StartAuditMitigationActionsTask, request, handler, context); } /** *

Starts a Device Defender ML Detect mitigation actions task.

Requires * permission to access the StartDetectMitigationActionsTask * action.

See Also:

AWS * API Reference

*/ virtual Model::StartDetectMitigationActionsTaskOutcome StartDetectMitigationActionsTask(const Model::StartDetectMitigationActionsTaskRequest& request) const; /** * A Callable wrapper for StartDetectMitigationActionsTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartDetectMitigationActionsTaskOutcomeCallable StartDetectMitigationActionsTaskCallable(const StartDetectMitigationActionsTaskRequestT& request) const { return SubmitCallable(&IoTClient::StartDetectMitigationActionsTask, request); } /** * An Async wrapper for StartDetectMitigationActionsTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartDetectMitigationActionsTaskAsync(const StartDetectMitigationActionsTaskRequestT& request, const StartDetectMitigationActionsTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::StartDetectMitigationActionsTask, request, handler, context); } /** *

Starts an on-demand Device Defender audit.

Requires permission to * access the StartOnDemandAuditTask * action.

See Also:

AWS * API Reference

*/ virtual Model::StartOnDemandAuditTaskOutcome StartOnDemandAuditTask(const Model::StartOnDemandAuditTaskRequest& request) const; /** * A Callable wrapper for StartOnDemandAuditTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartOnDemandAuditTaskOutcomeCallable StartOnDemandAuditTaskCallable(const StartOnDemandAuditTaskRequestT& request) const { return SubmitCallable(&IoTClient::StartOnDemandAuditTask, request); } /** * An Async wrapper for StartOnDemandAuditTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartOnDemandAuditTaskAsync(const StartOnDemandAuditTaskRequestT& request, const StartOnDemandAuditTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::StartOnDemandAuditTask, request, handler, context); } /** *

Creates a bulk thing provisioning task.

Requires permission to access * the StartThingRegistrationTask * action.

See Also:

AWS * API Reference

*/ virtual Model::StartThingRegistrationTaskOutcome StartThingRegistrationTask(const Model::StartThingRegistrationTaskRequest& request) const; /** * A Callable wrapper for StartThingRegistrationTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartThingRegistrationTaskOutcomeCallable StartThingRegistrationTaskCallable(const StartThingRegistrationTaskRequestT& request) const { return SubmitCallable(&IoTClient::StartThingRegistrationTask, request); } /** * An Async wrapper for StartThingRegistrationTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartThingRegistrationTaskAsync(const StartThingRegistrationTaskRequestT& request, const StartThingRegistrationTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::StartThingRegistrationTask, request, handler, context); } /** *

Cancels a bulk thing provisioning task.

Requires permission to access * the StopThingRegistrationTask * action.

See Also:

AWS * API Reference

*/ virtual Model::StopThingRegistrationTaskOutcome StopThingRegistrationTask(const Model::StopThingRegistrationTaskRequest& request) const; /** * A Callable wrapper for StopThingRegistrationTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopThingRegistrationTaskOutcomeCallable StopThingRegistrationTaskCallable(const StopThingRegistrationTaskRequestT& request) const { return SubmitCallable(&IoTClient::StopThingRegistrationTask, request); } /** * An Async wrapper for StopThingRegistrationTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopThingRegistrationTaskAsync(const StopThingRegistrationTaskRequestT& request, const StopThingRegistrationTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::StopThingRegistrationTask, request, handler, context); } /** *

Adds to or modifies the tags of the given resource. Tags are metadata which * can be used to manage a resource.

Requires permission to access the TagResource * action.

See Also:

AWS API * Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&IoTClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::TagResource, request, handler, context); } /** *

Tests if a specified principal is authorized to perform an IoT action on a * specified resource. Use this to test and debug the authorization behavior of * devices that connect to the IoT device gateway.

Requires permission to * access the TestAuthorization * action.

See Also:

AWS * API Reference

*/ virtual Model::TestAuthorizationOutcome TestAuthorization(const Model::TestAuthorizationRequest& request) const; /** * A Callable wrapper for TestAuthorization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestAuthorizationOutcomeCallable TestAuthorizationCallable(const TestAuthorizationRequestT& request) const { return SubmitCallable(&IoTClient::TestAuthorization, request); } /** * An Async wrapper for TestAuthorization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestAuthorizationAsync(const TestAuthorizationRequestT& request, const TestAuthorizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::TestAuthorization, request, handler, context); } /** *

Tests a custom authorization behavior by invoking a specified custom * authorizer. Use this to test and debug the custom authorization behavior of * devices that connect to the IoT device gateway.

Requires permission to * access the TestInvokeAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::TestInvokeAuthorizerOutcome TestInvokeAuthorizer(const Model::TestInvokeAuthorizerRequest& request) const; /** * A Callable wrapper for TestInvokeAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestInvokeAuthorizerOutcomeCallable TestInvokeAuthorizerCallable(const TestInvokeAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::TestInvokeAuthorizer, request); } /** * An Async wrapper for TestInvokeAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestInvokeAuthorizerAsync(const TestInvokeAuthorizerRequestT& request, const TestInvokeAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::TestInvokeAuthorizer, request, handler, context); } /** *

Transfers the specified certificate to the specified Amazon Web Services * account.

Requires permission to access the TransferCertificate * action.

You can cancel the transfer until it is acknowledged by the * recipient.

No notification is sent to the transfer destination's account. * It is up to the caller to notify the transfer target.

The certificate * being transferred must not be in the ACTIVE state. You can use the * UpdateCertificate action to deactivate it.

The certificate must * not have any policies attached to it. You can use the DetachPolicy action * to detach them.

See Also:

AWS * API Reference

*/ virtual Model::TransferCertificateOutcome TransferCertificate(const Model::TransferCertificateRequest& request) const; /** * A Callable wrapper for TransferCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TransferCertificateOutcomeCallable TransferCertificateCallable(const TransferCertificateRequestT& request) const { return SubmitCallable(&IoTClient::TransferCertificate, request); } /** * An Async wrapper for TransferCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TransferCertificateAsync(const TransferCertificateRequestT& request, const TransferCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::TransferCertificate, request, handler, context); } /** *

Removes the given tags (metadata) from the resource.

Requires * permission to access the UntagResource * action.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&IoTClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UntagResource, request, handler, context); } /** *

Configures or reconfigures the Device Defender audit settings for this * account. Settings include how audit notifications are sent and which audit * checks are enabled or disabled.

Requires permission to access the UpdateAccountAuditConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAccountAuditConfigurationOutcome UpdateAccountAuditConfiguration(const Model::UpdateAccountAuditConfigurationRequest& request) const; /** * A Callable wrapper for UpdateAccountAuditConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountAuditConfigurationOutcomeCallable UpdateAccountAuditConfigurationCallable(const UpdateAccountAuditConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::UpdateAccountAuditConfiguration, request); } /** * An Async wrapper for UpdateAccountAuditConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountAuditConfigurationAsync(const UpdateAccountAuditConfigurationRequestT& request, const UpdateAccountAuditConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateAccountAuditConfiguration, request, handler, context); } /** *

Updates a Device Defender audit suppression.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAuditSuppressionOutcome UpdateAuditSuppression(const Model::UpdateAuditSuppressionRequest& request) const; /** * A Callable wrapper for UpdateAuditSuppression that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAuditSuppressionOutcomeCallable UpdateAuditSuppressionCallable(const UpdateAuditSuppressionRequestT& request) const { return SubmitCallable(&IoTClient::UpdateAuditSuppression, request); } /** * An Async wrapper for UpdateAuditSuppression that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAuditSuppressionAsync(const UpdateAuditSuppressionRequestT& request, const UpdateAuditSuppressionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateAuditSuppression, request, handler, context); } /** *

Updates an authorizer.

Requires permission to access the UpdateAuthorizer * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAuthorizerOutcome UpdateAuthorizer(const Model::UpdateAuthorizerRequest& request) const; /** * A Callable wrapper for UpdateAuthorizer that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAuthorizerOutcomeCallable UpdateAuthorizerCallable(const UpdateAuthorizerRequestT& request) const { return SubmitCallable(&IoTClient::UpdateAuthorizer, request); } /** * An Async wrapper for UpdateAuthorizer that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAuthorizerAsync(const UpdateAuthorizerRequestT& request, const UpdateAuthorizerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateAuthorizer, request, handler, context); } /** *

Updates information about the billing group.

Requires permission to * access the UpdateBillingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateBillingGroupOutcome UpdateBillingGroup(const Model::UpdateBillingGroupRequest& request) const; /** * A Callable wrapper for UpdateBillingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateBillingGroupOutcomeCallable UpdateBillingGroupCallable(const UpdateBillingGroupRequestT& request) const { return SubmitCallable(&IoTClient::UpdateBillingGroup, request); } /** * An Async wrapper for UpdateBillingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateBillingGroupAsync(const UpdateBillingGroupRequestT& request, const UpdateBillingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateBillingGroup, request, handler, context); } /** *

Updates a registered CA certificate.

Requires permission to access the * UpdateCACertificate * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCACertificateOutcome UpdateCACertificate(const Model::UpdateCACertificateRequest& request) const; /** * A Callable wrapper for UpdateCACertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCACertificateOutcomeCallable UpdateCACertificateCallable(const UpdateCACertificateRequestT& request) const { return SubmitCallable(&IoTClient::UpdateCACertificate, request); } /** * An Async wrapper for UpdateCACertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCACertificateAsync(const UpdateCACertificateRequestT& request, const UpdateCACertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateCACertificate, request, handler, context); } /** *

Updates the status of the specified certificate. This operation is * idempotent.

Requires permission to access the UpdateCertificate * action.

Certificates must be in the ACTIVE state to authenticate devices * that use a certificate to connect to IoT.

Within a few minutes of * updating a certificate from the ACTIVE state to any other state, IoT disconnects * all devices that used that certificate to connect. Devices cannot use a * certificate that is not in the ACTIVE state to reconnect.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateCertificateOutcome UpdateCertificate(const Model::UpdateCertificateRequest& request) const; /** * A Callable wrapper for UpdateCertificate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCertificateOutcomeCallable UpdateCertificateCallable(const UpdateCertificateRequestT& request) const { return SubmitCallable(&IoTClient::UpdateCertificate, request); } /** * An Async wrapper for UpdateCertificate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCertificateAsync(const UpdateCertificateRequestT& request, const UpdateCertificateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateCertificate, request, handler, context); } /** *

Updates a Device Defender detect custom metric.

Requires permission * to access the UpdateCustomMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCustomMetricOutcome UpdateCustomMetric(const Model::UpdateCustomMetricRequest& request) const; /** * A Callable wrapper for UpdateCustomMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCustomMetricOutcomeCallable UpdateCustomMetricCallable(const UpdateCustomMetricRequestT& request) const { return SubmitCallable(&IoTClient::UpdateCustomMetric, request); } /** * An Async wrapper for UpdateCustomMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCustomMetricAsync(const UpdateCustomMetricRequestT& request, const UpdateCustomMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateCustomMetric, request, handler, context); } /** *

Updates the definition for a dimension. You cannot change the type of a * dimension after it is created (you can delete it and recreate it).

*

Requires permission to access the UpdateDimension * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDimensionOutcome UpdateDimension(const Model::UpdateDimensionRequest& request) const; /** * A Callable wrapper for UpdateDimension that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDimensionOutcomeCallable UpdateDimensionCallable(const UpdateDimensionRequestT& request) const { return SubmitCallable(&IoTClient::UpdateDimension, request); } /** * An Async wrapper for UpdateDimension that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDimensionAsync(const UpdateDimensionRequestT& request, const UpdateDimensionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateDimension, request, handler, context); } /** *

Updates values stored in the domain configuration. Domain configurations for * default endpoints can't be updated.

Requires permission to access the UpdateDomainConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDomainConfigurationOutcome UpdateDomainConfiguration(const Model::UpdateDomainConfigurationRequest& request) const; /** * A Callable wrapper for UpdateDomainConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDomainConfigurationOutcomeCallable UpdateDomainConfigurationCallable(const UpdateDomainConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::UpdateDomainConfiguration, request); } /** * An Async wrapper for UpdateDomainConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDomainConfigurationAsync(const UpdateDomainConfigurationRequestT& request, const UpdateDomainConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateDomainConfiguration, request, handler, context); } /** *

Updates a dynamic thing group.

Requires permission to access the UpdateDynamicThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDynamicThingGroupOutcome UpdateDynamicThingGroup(const Model::UpdateDynamicThingGroupRequest& request) const; /** * A Callable wrapper for UpdateDynamicThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDynamicThingGroupOutcomeCallable UpdateDynamicThingGroupCallable(const UpdateDynamicThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::UpdateDynamicThingGroup, request); } /** * An Async wrapper for UpdateDynamicThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDynamicThingGroupAsync(const UpdateDynamicThingGroupRequestT& request, const UpdateDynamicThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateDynamicThingGroup, request, handler, context); } /** *

Updates the event configurations.

Requires permission to access the UpdateEventConfigurations * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEventConfigurationsOutcome UpdateEventConfigurations(const Model::UpdateEventConfigurationsRequest& request) const; /** * A Callable wrapper for UpdateEventConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEventConfigurationsOutcomeCallable UpdateEventConfigurationsCallable(const UpdateEventConfigurationsRequestT& request) const { return SubmitCallable(&IoTClient::UpdateEventConfigurations, request); } /** * An Async wrapper for UpdateEventConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEventConfigurationsAsync(const UpdateEventConfigurationsRequestT& request, const UpdateEventConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateEventConfigurations, request, handler, context); } /** *

Updates the data for a fleet metric.

Requires permission to access the * UpdateFleetMetric * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFleetMetricOutcome UpdateFleetMetric(const Model::UpdateFleetMetricRequest& request) const; /** * A Callable wrapper for UpdateFleetMetric that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFleetMetricOutcomeCallable UpdateFleetMetricCallable(const UpdateFleetMetricRequestT& request) const { return SubmitCallable(&IoTClient::UpdateFleetMetric, request); } /** * An Async wrapper for UpdateFleetMetric that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFleetMetricAsync(const UpdateFleetMetricRequestT& request, const UpdateFleetMetricResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateFleetMetric, request, handler, context); } /** *

Updates the search configuration.

Requires permission to access the UpdateIndexingConfiguration * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateIndexingConfigurationOutcome UpdateIndexingConfiguration(const Model::UpdateIndexingConfigurationRequest& request) const; /** * A Callable wrapper for UpdateIndexingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateIndexingConfigurationOutcomeCallable UpdateIndexingConfigurationCallable(const UpdateIndexingConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::UpdateIndexingConfiguration, request); } /** * An Async wrapper for UpdateIndexingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateIndexingConfigurationAsync(const UpdateIndexingConfigurationRequestT& request, const UpdateIndexingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateIndexingConfiguration, request, handler, context); } /** *

Updates supported fields of the specified job.

Requires permission to * access the UpdateJob * action.

See Also:

AWS API * Reference

*/ virtual Model::UpdateJobOutcome UpdateJob(const Model::UpdateJobRequest& request) const; /** * A Callable wrapper for UpdateJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateJobOutcomeCallable UpdateJobCallable(const UpdateJobRequestT& request) const { return SubmitCallable(&IoTClient::UpdateJob, request); } /** * An Async wrapper for UpdateJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateJobAsync(const UpdateJobRequestT& request, const UpdateJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateJob, request, handler, context); } /** *

Updates the definition for the specified mitigation action.

Requires * permission to access the UpdateMitigationAction * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateMitigationActionOutcome UpdateMitigationAction(const Model::UpdateMitigationActionRequest& request) const; /** * A Callable wrapper for UpdateMitigationAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMitigationActionOutcomeCallable UpdateMitigationActionCallable(const UpdateMitigationActionRequestT& request) const { return SubmitCallable(&IoTClient::UpdateMitigationAction, request); } /** * An Async wrapper for UpdateMitigationAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMitigationActionAsync(const UpdateMitigationActionRequestT& request, const UpdateMitigationActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateMitigationAction, request, handler, context); } /** *

Updates the supported fields for a specific package.

Requires * permission to access the UpdatePackage * and GetIndexingConfiguration * actions.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePackageOutcome UpdatePackage(const Model::UpdatePackageRequest& request) const; /** * A Callable wrapper for UpdatePackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePackageOutcomeCallable UpdatePackageCallable(const UpdatePackageRequestT& request) const { return SubmitCallable(&IoTClient::UpdatePackage, request); } /** * An Async wrapper for UpdatePackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePackageAsync(const UpdatePackageRequestT& request, const UpdatePackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdatePackage, request, handler, context); } /** *

Updates the package configuration.

Requires permission to access the * UpdatePackageConfiguration * and iam:PassRole * actions.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePackageConfigurationOutcome UpdatePackageConfiguration(const Model::UpdatePackageConfigurationRequest& request) const; /** * A Callable wrapper for UpdatePackageConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePackageConfigurationOutcomeCallable UpdatePackageConfigurationCallable(const UpdatePackageConfigurationRequestT& request) const { return SubmitCallable(&IoTClient::UpdatePackageConfiguration, request); } /** * An Async wrapper for UpdatePackageConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePackageConfigurationAsync(const UpdatePackageConfigurationRequestT& request, const UpdatePackageConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdatePackageConfiguration, request, handler, context); } /** *

Updates the supported fields for a specific package version.

Requires * permission to access the UpdatePackageVersion * and GetIndexingConfiguration * actions.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePackageVersionOutcome UpdatePackageVersion(const Model::UpdatePackageVersionRequest& request) const; /** * A Callable wrapper for UpdatePackageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePackageVersionOutcomeCallable UpdatePackageVersionCallable(const UpdatePackageVersionRequestT& request) const { return SubmitCallable(&IoTClient::UpdatePackageVersion, request); } /** * An Async wrapper for UpdatePackageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePackageVersionAsync(const UpdatePackageVersionRequestT& request, const UpdatePackageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdatePackageVersion, request, handler, context); } /** *

Updates a provisioning template.

Requires permission to access the UpdateProvisioningTemplate * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateProvisioningTemplateOutcome UpdateProvisioningTemplate(const Model::UpdateProvisioningTemplateRequest& request) const; /** * A Callable wrapper for UpdateProvisioningTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateProvisioningTemplateOutcomeCallable UpdateProvisioningTemplateCallable(const UpdateProvisioningTemplateRequestT& request) const { return SubmitCallable(&IoTClient::UpdateProvisioningTemplate, request); } /** * An Async wrapper for UpdateProvisioningTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateProvisioningTemplateAsync(const UpdateProvisioningTemplateRequestT& request, const UpdateProvisioningTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateProvisioningTemplate, request, handler, context); } /** *

Updates a role alias.

Requires permission to access the UpdateRoleAlias * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRoleAliasOutcome UpdateRoleAlias(const Model::UpdateRoleAliasRequest& request) const; /** * A Callable wrapper for UpdateRoleAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRoleAliasOutcomeCallable UpdateRoleAliasCallable(const UpdateRoleAliasRequestT& request) const { return SubmitCallable(&IoTClient::UpdateRoleAlias, request); } /** * An Async wrapper for UpdateRoleAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRoleAliasAsync(const UpdateRoleAliasRequestT& request, const UpdateRoleAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateRoleAlias, request, handler, context); } /** *

Updates a scheduled audit, including which checks are performed and how often * the audit takes place.

Requires permission to access the UpdateScheduledAudit * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateScheduledAuditOutcome UpdateScheduledAudit(const Model::UpdateScheduledAuditRequest& request) const; /** * A Callable wrapper for UpdateScheduledAudit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateScheduledAuditOutcomeCallable UpdateScheduledAuditCallable(const UpdateScheduledAuditRequestT& request) const { return SubmitCallable(&IoTClient::UpdateScheduledAudit, request); } /** * An Async wrapper for UpdateScheduledAudit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateScheduledAuditAsync(const UpdateScheduledAuditRequestT& request, const UpdateScheduledAuditResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateScheduledAudit, request, handler, context); } /** *

Updates a Device Defender security profile.

Requires permission to * access the UpdateSecurityProfile * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSecurityProfileOutcome UpdateSecurityProfile(const Model::UpdateSecurityProfileRequest& request) const; /** * A Callable wrapper for UpdateSecurityProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSecurityProfileOutcomeCallable UpdateSecurityProfileCallable(const UpdateSecurityProfileRequestT& request) const { return SubmitCallable(&IoTClient::UpdateSecurityProfile, request); } /** * An Async wrapper for UpdateSecurityProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSecurityProfileAsync(const UpdateSecurityProfileRequestT& request, const UpdateSecurityProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateSecurityProfile, request, handler, context); } /** *

Updates an existing stream. The stream version will be incremented by * one.

Requires permission to access the UpdateStream * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStreamOutcome UpdateStream(const Model::UpdateStreamRequest& request) const; /** * A Callable wrapper for UpdateStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStreamOutcomeCallable UpdateStreamCallable(const UpdateStreamRequestT& request) const { return SubmitCallable(&IoTClient::UpdateStream, request); } /** * An Async wrapper for UpdateStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStreamAsync(const UpdateStreamRequestT& request, const UpdateStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateStream, request, handler, context); } /** *

Updates the data for a thing.

Requires permission to access the UpdateThing * action.

See Also:

AWS API * Reference

*/ virtual Model::UpdateThingOutcome UpdateThing(const Model::UpdateThingRequest& request) const; /** * A Callable wrapper for UpdateThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateThingOutcomeCallable UpdateThingCallable(const UpdateThingRequestT& request) const { return SubmitCallable(&IoTClient::UpdateThing, request); } /** * An Async wrapper for UpdateThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateThingAsync(const UpdateThingRequestT& request, const UpdateThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateThing, request, handler, context); } /** *

Update a thing group.

Requires permission to access the UpdateThingGroup * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateThingGroupOutcome UpdateThingGroup(const Model::UpdateThingGroupRequest& request) const; /** * A Callable wrapper for UpdateThingGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateThingGroupOutcomeCallable UpdateThingGroupCallable(const UpdateThingGroupRequestT& request) const { return SubmitCallable(&IoTClient::UpdateThingGroup, request); } /** * An Async wrapper for UpdateThingGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateThingGroupAsync(const UpdateThingGroupRequestT& request, const UpdateThingGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateThingGroup, request, handler, context); } /** *

Updates the groups to which the thing belongs.

Requires permission to * access the UpdateThingGroupsForThing * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateThingGroupsForThingOutcome UpdateThingGroupsForThing(const Model::UpdateThingGroupsForThingRequest& request) const; /** * A Callable wrapper for UpdateThingGroupsForThing that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateThingGroupsForThingOutcomeCallable UpdateThingGroupsForThingCallable(const UpdateThingGroupsForThingRequestT& request) const { return SubmitCallable(&IoTClient::UpdateThingGroupsForThing, request); } /** * An Async wrapper for UpdateThingGroupsForThing that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateThingGroupsForThingAsync(const UpdateThingGroupsForThingRequestT& request, const UpdateThingGroupsForThingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateThingGroupsForThing, request, handler, context); } /** *

Updates a topic rule destination. You use this to change the status, endpoint * URL, or confirmation URL of the destination.

Requires permission to * access the UpdateTopicRuleDestination * action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTopicRuleDestinationOutcome UpdateTopicRuleDestination(const Model::UpdateTopicRuleDestinationRequest& request) const; /** * A Callable wrapper for UpdateTopicRuleDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTopicRuleDestinationOutcomeCallable UpdateTopicRuleDestinationCallable(const UpdateTopicRuleDestinationRequestT& request) const { return SubmitCallable(&IoTClient::UpdateTopicRuleDestination, request); } /** * An Async wrapper for UpdateTopicRuleDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTopicRuleDestinationAsync(const UpdateTopicRuleDestinationRequestT& request, const UpdateTopicRuleDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::UpdateTopicRuleDestination, request, handler, context); } /** *

Validates a Device Defender security profile behaviors specification.

*

Requires permission to access the ValidateSecurityProfileBehaviors * action.

See Also:

AWS * API Reference

*/ virtual Model::ValidateSecurityProfileBehaviorsOutcome ValidateSecurityProfileBehaviors(const Model::ValidateSecurityProfileBehaviorsRequest& request) const; /** * A Callable wrapper for ValidateSecurityProfileBehaviors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ValidateSecurityProfileBehaviorsOutcomeCallable ValidateSecurityProfileBehaviorsCallable(const ValidateSecurityProfileBehaviorsRequestT& request) const { return SubmitCallable(&IoTClient::ValidateSecurityProfileBehaviors, request); } /** * An Async wrapper for ValidateSecurityProfileBehaviors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ValidateSecurityProfileBehaviorsAsync(const ValidateSecurityProfileBehaviorsRequestT& request, const ValidateSecurityProfileBehaviorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTClient::ValidateSecurityProfileBehaviors, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const IoTClientConfiguration& clientConfiguration); IoTClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace IoT } // namespace Aws