/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the iot-2015-05-28.normal.json service model. */ using System; using System.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using System.Net; using Amazon.IoT.Model; using Amazon.IoT.Model.Internal.MarshallTransformations; using Amazon.IoT.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.IoT { ///

/// Implementation for accessing 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. /// ///

public partial class AmazonIoTClient : AmazonServiceClient, IAmazonIoT { private static IServiceMetadata serviceMetadata = new AmazonIoTMetadata(); #region Constructors ///

/// Constructs AmazonIoTClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonIoTClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonIoTConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonIoTClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonIoTConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonIoTClient Configuration Object public AmazonIoTClient(AmazonIoTConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonIoTClient with AWS Credentials ///

/// AWS Credentials public AmazonIoTClient(AWSCredentials credentials) : this(credentials, new AmazonIoTConfig()) { } ///

/// Constructs AmazonIoTClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonIoTClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonIoTConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonIoTClient with AWS Credentials and an /// AmazonIoTClient Configuration object. ///

/// AWS Credentials /// The AmazonIoTClient Configuration Object public AmazonIoTClient(AWSCredentials credentials, AmazonIoTConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonIoTClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonIoTClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonIoTConfig()) { } ///

/// Constructs AmazonIoTClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonIoTClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonIoTConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonIoTClient with AWS Access Key ID, AWS Secret Key and an /// AmazonIoTClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonIoTClient Configuration Object public AmazonIoTClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonIoTConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonIoTClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonIoTClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonIoTConfig()) { } ///

/// Constructs AmazonIoTClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonIoTClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonIoTConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonIoTClient with AWS Access Key ID, AWS Secret Key and an /// AmazonIoTClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonIoTClient Configuration Object public AmazonIoTClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonIoTConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #if AWS_ASYNC_ENUMERABLES_API private IIoTPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IIoTPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new IoTPaginatorFactory(this); } return this._paginators; } } #endif #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customizes the runtime pipeline. ///

/// Runtime pipeline for the current client. protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonIoTEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AcceptCertificateTransfer internal virtual AcceptCertificateTransferResponse AcceptCertificateTransfer(AcceptCertificateTransferRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptCertificateTransferRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptCertificateTransferResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AcceptCertificateTransfer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AcceptCertificateTransfer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You can't revert the certificate transfer because the transfer is already complete. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for AcceptCertificateTransfer Operation public virtual Task AcceptCertificateTransferAsync(AcceptCertificateTransferRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptCertificateTransferRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptCertificateTransferResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddThingToBillingGroup internal virtual AddThingToBillingGroupResponse AddThingToBillingGroup(AddThingToBillingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddThingToBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = AddThingToBillingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds a thing to a billing group. /// /// /// /// Requires permission to access the AddThingToBillingGroup /// action. /// ///

/// Container for the necessary parameters to execute the AddThingToBillingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddThingToBillingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for AddThingToBillingGroup Operation public virtual Task AddThingToBillingGroupAsync(AddThingToBillingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddThingToBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = AddThingToBillingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddThingToThingGroup internal virtual AddThingToThingGroupResponse AddThingToThingGroup(AddThingToThingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddThingToThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = AddThingToThingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds a thing to a thing group. /// /// /// /// Requires permission to access the AddThingToThingGroup /// action. /// ///

/// Container for the necessary parameters to execute the AddThingToThingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddThingToThingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for AddThingToThingGroup Operation public virtual Task AddThingToThingGroupAsync(AddThingToThingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddThingToThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = AddThingToThingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AssociateTargetsWithJob internal virtual AssociateTargetsWithJobResponse AssociateTargetsWithJob(AssociateTargetsWithJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTargetsWithJobRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTargetsWithJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AssociateTargetsWithJob service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateTargetsWithJob service method, as returned by IoT. /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for AssociateTargetsWithJob Operation public virtual Task AssociateTargetsWithJobAsync(AssociateTargetsWithJobRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateTargetsWithJobRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateTargetsWithJobResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AttachPolicy internal virtual AttachPolicyResponse AttachPolicy(AttachPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Attaches the specified policy to the specified principal (certificate or other credential). /// /// /// /// Requires permission to access the AttachPolicy /// action. /// ///

/// Container for the necessary parameters to execute the AttachPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachPolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for AttachPolicy Operation public virtual Task AttachPolicyAsync(AttachPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AttachPrincipalPolicy [Obsolete("Deprecated in favor of AttachPolicy.")] internal virtual AttachPrincipalPolicyResponse AttachPrincipalPolicy(AttachPrincipalPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachPrincipalPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachPrincipalPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Attaches the specified policy to the specified principal (certificate or other credential). /// /// /// /// Note: This action is deprecated and works as expected for backward compatibility, /// but we won't add enhancements. Use AttachPolicy instead. /// /// /// /// Requires permission to access the AttachPrincipalPolicy /// action. /// ///

/// The policy name. /// The principal, which can be a certificate ARN (as returned from the CreateCertificate operation) or an Amazon Cognito ID. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachPrincipalPolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for AttachPrincipalPolicy Operation [Obsolete("Deprecated in favor of AttachPolicy.")] public virtual Task AttachPrincipalPolicyAsync(string policyName, string principal, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new AttachPrincipalPolicyRequest(); request.PolicyName = policyName; request.Principal = principal; return AttachPrincipalPolicyAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the AttachPrincipalPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachPrincipalPolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for AttachPrincipalPolicy Operation [Obsolete("Deprecated in favor of AttachPolicy.")] public virtual Task AttachPrincipalPolicyAsync(AttachPrincipalPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachPrincipalPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachPrincipalPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AttachSecurityProfile internal virtual AttachSecurityProfileResponse AttachSecurityProfile(AttachSecurityProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachSecurityProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AttachSecurityProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachSecurityProfile service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for AttachSecurityProfile Operation public virtual Task AttachSecurityProfileAsync(AttachSecurityProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachSecurityProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AttachThingPrincipal internal virtual AttachThingPrincipalResponse AttachThingPrincipal(AttachThingPrincipalRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AttachThingPrincipalRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachThingPrincipalResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The name of the thing. /// The principal, which can be a certificate ARN (as returned from the CreateCertificate operation) or an Amazon Cognito ID. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachThingPrincipal service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for AttachThingPrincipal Operation public virtual Task AttachThingPrincipalAsync(string thingName, string principal, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new AttachThingPrincipalRequest(); request.ThingName = thingName; request.Principal = principal; return AttachThingPrincipalAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the AttachThingPrincipal service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AttachThingPrincipal service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for AttachThingPrincipal Operation public virtual Task AttachThingPrincipalAsync(AttachThingPrincipalRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AttachThingPrincipalRequestMarshaller.Instance; options.ResponseUnmarshaller = AttachThingPrincipalResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelAuditMitigationActionsTask internal virtual CancelAuditMitigationActionsTaskResponse CancelAuditMitigationActionsTask(CancelAuditMitigationActionsTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelAuditMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelAuditMitigationActionsTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CancelAuditMitigationActionsTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelAuditMitigationActionsTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CancelAuditMitigationActionsTask Operation public virtual Task CancelAuditMitigationActionsTaskAsync(CancelAuditMitigationActionsTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelAuditMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelAuditMitigationActionsTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelAuditTask internal virtual CancelAuditTaskResponse CancelAuditTask(CancelAuditTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelAuditTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelAuditTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CancelAuditTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelAuditTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CancelAuditTask Operation public virtual Task CancelAuditTaskAsync(CancelAuditTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelAuditTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelAuditTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelCertificateTransfer internal virtual CancelCertificateTransferResponse CancelCertificateTransfer(CancelCertificateTransferRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCertificateTransferRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCertificateTransferResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.) /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCertificateTransfer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You can't revert the certificate transfer because the transfer is already complete. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CancelCertificateTransfer Operation public virtual Task CancelCertificateTransferAsync(string certificateId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CancelCertificateTransferRequest(); request.CertificateId = certificateId; return CancelCertificateTransferAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the CancelCertificateTransfer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCertificateTransfer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You can't revert the certificate transfer because the transfer is already complete. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CancelCertificateTransfer Operation public virtual Task CancelCertificateTransferAsync(CancelCertificateTransferRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCertificateTransferRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCertificateTransferResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelDetectMitigationActionsTask internal virtual CancelDetectMitigationActionsTaskResponse CancelDetectMitigationActionsTask(CancelDetectMitigationActionsTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelDetectMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelDetectMitigationActionsTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Cancels a Device Defender ML Detect mitigation action. /// /// /// /// Requires permission to access the CancelDetectMitigationActionsTask /// action. /// ///

/// Container for the necessary parameters to execute the CancelDetectMitigationActionsTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelDetectMitigationActionsTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CancelDetectMitigationActionsTask Operation public virtual Task CancelDetectMitigationActionsTaskAsync(CancelDetectMitigationActionsTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelDetectMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelDetectMitigationActionsTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelJob internal virtual CancelJobResponse CancelJob(CancelJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Cancels a job. /// /// /// /// Requires permission to access the CancelJob /// action. /// ///

/// Container for the necessary parameters to execute the CancelJob service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelJob service method, as returned by IoT. /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CancelJob Operation public virtual Task CancelJobAsync(CancelJobRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelJobResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelJobExecution internal virtual CancelJobExecutionResponse CancelJobExecution(CancelJobExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelJobExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Cancels the execution of a job for a given thing. /// /// /// /// Requires permission to access the CancelJobExecution /// action. /// ///

/// Container for the necessary parameters to execute the CancelJobExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelJobExecution service method, as returned by IoT. /// /// The request is not valid. /// /// /// An attempt was made to change to an invalid state, for example by deleting a job or /// a job execution which is "IN_PROGRESS" without setting the force parameter. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for CancelJobExecution Operation public virtual Task CancelJobExecutionAsync(CancelJobExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelJobExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ClearDefaultAuthorizer internal virtual ClearDefaultAuthorizerResponse ClearDefaultAuthorizer(ClearDefaultAuthorizerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ClearDefaultAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = ClearDefaultAuthorizerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Clears the default authorizer. /// /// /// /// Requires permission to access the ClearDefaultAuthorizer /// action. /// ///

/// Container for the necessary parameters to execute the ClearDefaultAuthorizer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ClearDefaultAuthorizer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for ClearDefaultAuthorizer Operation public virtual Task ClearDefaultAuthorizerAsync(ClearDefaultAuthorizerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ClearDefaultAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = ClearDefaultAuthorizerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ConfirmTopicRuleDestination internal virtual ConfirmTopicRuleDestinationResponse ConfirmTopicRuleDestination(ConfirmTopicRuleDestinationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ConfirmTopicRuleDestinationRequestMarshaller.Instance; options.ResponseUnmarshaller = ConfirmTopicRuleDestinationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ConfirmTopicRuleDestination service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ConfirmTopicRuleDestination service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for ConfirmTopicRuleDestination Operation public virtual Task ConfirmTopicRuleDestinationAsync(ConfirmTopicRuleDestinationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ConfirmTopicRuleDestinationRequestMarshaller.Instance; options.ResponseUnmarshaller = ConfirmTopicRuleDestinationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAuditSuppression internal virtual CreateAuditSuppressionResponse CreateAuditSuppression(CreateAuditSuppressionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAuditSuppressionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAuditSuppressionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a Device Defender audit suppression. /// /// /// /// Requires permission to access the CreateAuditSuppression /// action. /// ///

/// Container for the necessary parameters to execute the CreateAuditSuppression service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAuditSuppression service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateAuditSuppression Operation public virtual Task CreateAuditSuppressionAsync(CreateAuditSuppressionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAuditSuppressionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAuditSuppressionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAuthorizer internal virtual CreateAuthorizerResponse CreateAuthorizer(CreateAuthorizerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAuthorizerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an authorizer. /// /// /// /// Requires permission to access the CreateAuthorizer /// action. /// ///

/// Container for the necessary parameters to execute the CreateAuthorizer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAuthorizer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateAuthorizer Operation public virtual Task CreateAuthorizerAsync(CreateAuthorizerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAuthorizerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateBillingGroup internal virtual CreateBillingGroupResponse CreateBillingGroup(CreateBillingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBillingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a billing group. /// /// /// /// Requires permission to access the CreateBillingGroup /// action. /// ///

/// Container for the necessary parameters to execute the CreateBillingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateBillingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateBillingGroup Operation public virtual Task CreateBillingGroupAsync(CreateBillingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateBillingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCertificateFromCsr internal virtual CreateCertificateFromCsrResponse CreateCertificateFromCsr(CreateCertificateFromCsrRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCertificateFromCsrRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCertificateFromCsrResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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"

/// ///

/// The certificate signing request (CSR). /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCertificateFromCsr service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateCertificateFromCsr Operation public virtual Task CreateCertificateFromCsrAsync(string certificateSigningRequest, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateCertificateFromCsrRequest(); request.CertificateSigningRequest = certificateSigningRequest; return CreateCertificateFromCsrAsync(request, cancellationToken); } ///

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

$ 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"

/// ///

/// The certificate signing request (CSR). /// Specifies whether the certificate is active. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCertificateFromCsr service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateCertificateFromCsr Operation public virtual Task CreateCertificateFromCsrAsync(string certificateSigningRequest, bool setAsActive, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateCertificateFromCsrRequest(); request.CertificateSigningRequest = certificateSigningRequest; request.SetAsActive = setAsActive; return CreateCertificateFromCsrAsync(request, cancellationToken); } ///

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

$ 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"

/// ///

/// Container for the necessary parameters to execute the CreateCertificateFromCsr service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCertificateFromCsr service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateCertificateFromCsr Operation public virtual Task CreateCertificateFromCsrAsync(CreateCertificateFromCsrRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCertificateFromCsrRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCertificateFromCsrResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateCustomMetric internal virtual CreateCustomMetricResponse CreateCustomMetric(CreateCustomMetricRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomMetricResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Use this API to define a Custom Metric published by your devices to Device Defender. /// /// /// /// /// Requires permission to access the CreateCustomMetric /// action. /// ///

/// Container for the necessary parameters to execute the CreateCustomMetric service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateCustomMetric service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateCustomMetric Operation public virtual Task CreateCustomMetricAsync(CreateCustomMetricRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateCustomMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateCustomMetricResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDimension internal virtual CreateDimensionResponse CreateDimension(CreateDimensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDimensionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDimensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateDimension service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDimension service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateDimension Operation public virtual Task CreateDimensionAsync(CreateDimensionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDimensionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDimensionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDomainConfiguration internal virtual CreateDomainConfigurationResponse CreateDomainConfiguration(CreateDomainConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a domain configuration. /// /// /// /// Requires permission to access the CreateDomainConfiguration /// action. /// ///

/// Container for the necessary parameters to execute the CreateDomainConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDomainConfiguration service method, as returned by IoT. /// /// The certificate is invalid. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateDomainConfiguration Operation public virtual Task CreateDomainConfigurationAsync(CreateDomainConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDomainConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDomainConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDynamicThingGroup internal virtual CreateDynamicThingGroupResponse CreateDynamicThingGroup(CreateDynamicThingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDynamicThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDynamicThingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a dynamic thing group. /// /// /// /// Requires permission to access the CreateDynamicThingGroup /// action. /// ///

/// Container for the necessary parameters to execute the CreateDynamicThingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDynamicThingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The query is invalid. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateDynamicThingGroup Operation public virtual Task CreateDynamicThingGroupAsync(CreateDynamicThingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDynamicThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDynamicThingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateFleetMetric internal virtual CreateFleetMetricResponse CreateFleetMetric(CreateFleetMetricRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFleetMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFleetMetricResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a fleet metric. /// /// /// /// Requires permission to access the CreateFleetMetric /// action. /// ///

/// Container for the necessary parameters to execute the CreateFleetMetric service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateFleetMetric service method, as returned by IoT. /// /// The index is not ready. /// /// /// An unexpected error has occurred. /// /// /// The aggregation is invalid. /// /// /// The query is invalid. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateFleetMetric Operation public virtual Task CreateFleetMetricAsync(CreateFleetMetricRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateFleetMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateFleetMetricResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateJob internal virtual CreateJobResponse CreateJob(CreateJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a job. /// /// /// /// Requires permission to access the CreateJob /// action. /// ///

/// Container for the necessary parameters to execute the CreateJob service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateJob service method, as returned by IoT. /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateJob Operation public virtual Task CreateJobAsync(CreateJobRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateJobRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateJobResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateJobTemplate internal virtual CreateJobTemplateResponse CreateJobTemplate(CreateJobTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateJobTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a job template. /// /// /// /// Requires permission to access the CreateJobTemplate /// action. /// ///

/// Container for the necessary parameters to execute the CreateJobTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateJobTemplate service method, as returned by IoT. /// /// A resource with the same name already exists. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateJobTemplate Operation public virtual Task CreateJobTemplateAsync(CreateJobTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateJobTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateKeysAndCertificate internal virtual CreateKeysAndCertificateResponse CreateKeysAndCertificate(CreateKeysAndCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKeysAndCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKeysAndCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateKeysAndCertificate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateKeysAndCertificate Operation public virtual Task CreateKeysAndCertificateAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateKeysAndCertificateRequest(); return CreateKeysAndCertificateAsync(request, cancellationToken); } ///

/// Specifies whether the certificate is active. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateKeysAndCertificate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateKeysAndCertificate Operation public virtual Task CreateKeysAndCertificateAsync(bool setAsActive, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateKeysAndCertificateRequest(); request.SetAsActive = setAsActive; return CreateKeysAndCertificateAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the CreateKeysAndCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateKeysAndCertificate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateKeysAndCertificate Operation public virtual Task CreateKeysAndCertificateAsync(CreateKeysAndCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKeysAndCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKeysAndCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateMitigationAction internal virtual CreateMitigationActionResponse CreateMitigationAction(CreateMitigationActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMitigationActionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMitigationActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateMitigationAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateMitigationAction service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateMitigationAction Operation public virtual Task CreateMitigationActionAsync(CreateMitigationActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMitigationActionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMitigationActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateOTAUpdate internal virtual CreateOTAUpdateResponse CreateOTAUpdate(CreateOTAUpdateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOTAUpdateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOTAUpdateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an IoT OTA update on a target group of things or groups. /// /// /// /// Requires permission to access the CreateOTAUpdate /// action. /// ///

/// Container for the necessary parameters to execute the CreateOTAUpdate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateOTAUpdate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateOTAUpdate Operation public virtual Task CreateOTAUpdateAsync(CreateOTAUpdateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOTAUpdateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOTAUpdateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreatePackage internal virtual CreatePackageResponse CreatePackage(CreatePackageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePackageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePackageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates an IoT software package that can be deployed to your fleet. /// /// /// /// Requires permission to access the CreatePackage /// and GetIndexingConfiguration /// actions. /// ///

/// Container for the necessary parameters to execute the CreatePackage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePackage service method, as returned by IoT. /// /// A resource with the same name already exists. /// /// /// Internal error from the service that indicates an unexpected error or that the service /// is unavailable. /// /// /// A limit has been exceeded. /// /// /// The rate exceeds the limit. /// /// /// The request is not valid. /// /// REST API Reference for CreatePackage Operation public virtual Task CreatePackageAsync(CreatePackageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePackageRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePackageResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreatePackageVersion internal virtual CreatePackageVersionResponse CreatePackageVersion(CreatePackageVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePackageVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePackageVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new version for an existing IoT software package. /// /// /// /// Requires permission to access the CreatePackageVersion /// and GetIndexingConfiguration /// actions. /// ///

/// Container for the necessary parameters to execute the CreatePackageVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePackageVersion service method, as returned by IoT. /// /// A resource with the same name already exists. /// /// /// Internal error from the service that indicates an unexpected error or that the service /// is unavailable. /// /// /// A limit has been exceeded. /// /// /// The rate exceeds the limit. /// /// /// The request is not valid. /// /// REST API Reference for CreatePackageVersion Operation public virtual Task CreatePackageVersionAsync(CreatePackageVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePackageVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePackageVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreatePolicy internal virtual CreatePolicyResponse CreatePolicy(CreatePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The policy name. /// The JSON document that describes the policy. policyDocument must have a minimum length of 1, with a maximum length of 2048, excluding whitespace. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The policy documentation is not valid. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreatePolicy Operation public virtual Task CreatePolicyAsync(string policyName, string policyDocument, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreatePolicyRequest(); request.PolicyName = policyName; request.PolicyDocument = policyDocument; return CreatePolicyAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the CreatePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The policy documentation is not valid. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreatePolicy Operation public virtual Task CreatePolicyAsync(CreatePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreatePolicyVersion internal virtual CreatePolicyVersionResponse CreatePolicyVersion(CreatePolicyVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePolicyVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePolicyVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The policy name. /// The JSON document that describes the policy. Minimum length of 1. Maximum length of 2048, excluding whitespace. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePolicyVersion service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The policy documentation is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// The number of policy versions exceeds the limit. /// /// REST API Reference for CreatePolicyVersion Operation public virtual Task CreatePolicyVersionAsync(string policyName, string policyDocument, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreatePolicyVersionRequest(); request.PolicyName = policyName; request.PolicyDocument = policyDocument; return CreatePolicyVersionAsync(request, cancellationToken); } ///

/// The policy name. /// The JSON document that describes the policy. Minimum length of 1. Maximum length of 2048, excluding whitespace. /// Specifies whether the policy version is set as the default. When this parameter is true, the new policy version becomes the operative version (that is, the version that is in effect for the certificates to which the policy is attached). /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePolicyVersion service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The policy documentation is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// The number of policy versions exceeds the limit. /// /// REST API Reference for CreatePolicyVersion Operation public virtual Task CreatePolicyVersionAsync(string policyName, string policyDocument, bool setAsDefault, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreatePolicyVersionRequest(); request.PolicyName = policyName; request.PolicyDocument = policyDocument; request.SetAsDefault = setAsDefault; return CreatePolicyVersionAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the CreatePolicyVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePolicyVersion service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The policy documentation is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// The number of policy versions exceeds the limit. /// /// REST API Reference for CreatePolicyVersion Operation public virtual Task CreatePolicyVersionAsync(CreatePolicyVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePolicyVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePolicyVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateProvisioningClaim internal virtual CreateProvisioningClaimResponse CreateProvisioningClaim(CreateProvisioningClaimRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProvisioningClaimRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProvisioningClaimResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a provisioning claim. /// /// /// /// Requires permission to access the CreateProvisioningClaim /// action. /// ///

/// Container for the necessary parameters to execute the CreateProvisioningClaim service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateProvisioningClaim service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateProvisioningClaim Operation public virtual Task CreateProvisioningClaimAsync(CreateProvisioningClaimRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProvisioningClaimRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProvisioningClaimResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateProvisioningTemplate internal virtual CreateProvisioningTemplateResponse CreateProvisioningTemplate(CreateProvisioningTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProvisioningTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProvisioningTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a provisioning template. /// /// /// /// Requires permission to access the CreateProvisioningTemplate /// action. /// ///

/// Container for the necessary parameters to execute the CreateProvisioningTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateProvisioningTemplate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateProvisioningTemplate Operation public virtual Task CreateProvisioningTemplateAsync(CreateProvisioningTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProvisioningTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProvisioningTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateProvisioningTemplateVersion internal virtual CreateProvisioningTemplateVersionResponse CreateProvisioningTemplateVersion(CreateProvisioningTemplateVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProvisioningTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProvisioningTemplateVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new version of a provisioning template. /// /// /// /// Requires permission to access the CreateProvisioningTemplateVersion /// action. /// ///

/// Container for the necessary parameters to execute the CreateProvisioningTemplateVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateProvisioningTemplateVersion service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// The number of policy versions exceeds the limit. /// /// REST API Reference for CreateProvisioningTemplateVersion Operation public virtual Task CreateProvisioningTemplateVersionAsync(CreateProvisioningTemplateVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateProvisioningTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateProvisioningTemplateVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateRoleAlias internal virtual CreateRoleAliasResponse CreateRoleAlias(CreateRoleAliasRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRoleAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRoleAliasResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a role alias. /// /// /// /// Requires permission to access the CreateRoleAlias /// action. /// ///

/// Container for the necessary parameters to execute the CreateRoleAlias service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateRoleAlias service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateRoleAlias Operation public virtual Task CreateRoleAliasAsync(CreateRoleAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateRoleAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateRoleAliasResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateScheduledAudit internal virtual CreateScheduledAuditResponse CreateScheduledAudit(CreateScheduledAuditRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateScheduledAuditRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateScheduledAuditResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a scheduled audit that is run at a specified time interval. /// /// /// /// Requires permission to access the CreateScheduledAudit /// action. /// ///

/// Container for the necessary parameters to execute the CreateScheduledAudit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateScheduledAudit service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateScheduledAudit Operation public virtual Task CreateScheduledAuditAsync(CreateScheduledAuditRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateScheduledAuditRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateScheduledAuditResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateSecurityProfile internal virtual CreateSecurityProfileResponse CreateSecurityProfile(CreateSecurityProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSecurityProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a Device Defender security profile. /// /// /// /// Requires permission to access the CreateSecurityProfile /// action. /// ///

/// Container for the necessary parameters to execute the CreateSecurityProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSecurityProfile service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateSecurityProfile Operation public virtual Task CreateSecurityProfileAsync(CreateSecurityProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSecurityProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateStream internal virtual CreateStreamResponse CreateStream(CreateStreamRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateStreamResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateStream service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateStream service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The resource already exists. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateStream Operation public virtual Task CreateStreamAsync(CreateStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateStreamResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateThing internal virtual CreateThingResponse CreateThing(CreateThingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateThingRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateThingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateThing service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateThing service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateThing Operation public virtual Task CreateThingAsync(CreateThingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateThingRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateThingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateThingGroup internal virtual CreateThingGroupResponse CreateThingGroup(CreateThingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateThingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateThingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateThingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The rate exceeds the limit. /// /// REST API Reference for CreateThingGroup Operation public virtual Task CreateThingGroupAsync(CreateThingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateThingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateThingType internal virtual CreateThingTypeResponse CreateThingType(CreateThingTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateThingTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a new thing type. /// /// /// /// Requires permission to access the CreateThingType /// action. /// ///

/// Container for the necessary parameters to execute the CreateThingType service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateThingType service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for CreateThingType Operation public virtual Task CreateThingTypeAsync(CreateThingTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateThingTypeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTopicRule internal virtual CreateTopicRuleResponse CreateTopicRule(CreateTopicRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTopicRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateTopicRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTopicRule service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// /// The Rule-SQL expression can't be parsed correctly. /// /// REST API Reference for CreateTopicRule Operation public virtual Task CreateTopicRuleAsync(CreateTopicRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTopicRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTopicRuleDestination internal virtual CreateTopicRuleDestinationResponse CreateTopicRuleDestination(CreateTopicRuleDestinationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTopicRuleDestinationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTopicRuleDestinationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a topic rule destination. The destination must be confirmed prior to use. /// /// /// /// Requires permission to access the CreateTopicRuleDestination /// action. /// ///

/// Container for the necessary parameters to execute the CreateTopicRuleDestination service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateTopicRuleDestination service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The resource already exists. /// /// /// The service is temporarily unavailable. /// /// REST API Reference for CreateTopicRuleDestination Operation public virtual Task CreateTopicRuleDestinationAsync(CreateTopicRuleDestinationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTopicRuleDestinationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTopicRuleDestinationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAccountAuditConfiguration internal virtual DeleteAccountAuditConfigurationResponse DeleteAccountAuditConfiguration(DeleteAccountAuditConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAccountAuditConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAccountAuditConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteAccountAuditConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAccountAuditConfiguration service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteAccountAuditConfiguration Operation public virtual Task DeleteAccountAuditConfigurationAsync(DeleteAccountAuditConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAccountAuditConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAccountAuditConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAuditSuppression internal virtual DeleteAuditSuppressionResponse DeleteAuditSuppression(DeleteAuditSuppressionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuditSuppressionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuditSuppressionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a Device Defender audit suppression. /// /// /// /// Requires permission to access the DeleteAuditSuppression /// action. /// ///

/// Container for the necessary parameters to execute the DeleteAuditSuppression service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAuditSuppression service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteAuditSuppression Operation public virtual Task DeleteAuditSuppressionAsync(DeleteAuditSuppressionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuditSuppressionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuditSuppressionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAuthorizer internal virtual DeleteAuthorizerResponse DeleteAuthorizer(DeleteAuthorizerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuthorizerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes an authorizer. /// /// /// /// Requires permission to access the DeleteAuthorizer /// action. /// ///

/// Container for the necessary parameters to execute the DeleteAuthorizer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAuthorizer service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteAuthorizer Operation public virtual Task DeleteAuthorizerAsync(DeleteAuthorizerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAuthorizerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteBillingGroup internal virtual DeleteBillingGroupResponse DeleteBillingGroup(DeleteBillingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBillingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the billing group. /// /// /// /// Requires permission to access the DeleteBillingGroup /// action. /// ///

/// Container for the necessary parameters to execute the DeleteBillingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteBillingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteBillingGroup Operation public virtual Task DeleteBillingGroupAsync(DeleteBillingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteBillingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteCACertificate internal virtual DeleteCACertificateResponse DeleteCACertificate(DeleteCACertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCACertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCACertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a registered CA certificate. /// /// /// /// Requires permission to access the DeleteCACertificate /// action. /// ///

/// Container for the necessary parameters to execute the DeleteCACertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCACertificate service method, as returned by IoT. /// /// The certificate operation is not allowed. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteCACertificate Operation public virtual Task DeleteCACertificateAsync(DeleteCACertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCACertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCACertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteCertificate internal virtual DeleteCertificateResponse DeleteCertificate(DeleteCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.) /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCertificate service method, as returned by IoT. /// /// The certificate operation is not allowed. /// /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteCertificate Operation public virtual Task DeleteCertificateAsync(string certificateId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeleteCertificateRequest(); request.CertificateId = certificateId; return DeleteCertificateAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DeleteCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCertificate service method, as returned by IoT. /// /// The certificate operation is not allowed. /// /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteCertificate Operation public virtual Task DeleteCertificateAsync(DeleteCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteCustomMetric internal virtual DeleteCustomMetricResponse DeleteCustomMetric(DeleteCustomMetricRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomMetricResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the DeleteCustomMetric service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteCustomMetric service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteCustomMetric Operation public virtual Task DeleteCustomMetricAsync(DeleteCustomMetricRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteCustomMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteCustomMetricResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDimension internal virtual DeleteDimensionResponse DeleteDimension(DeleteDimensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDimensionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDimensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes the specified dimension from your Amazon Web Services accounts. /// /// /// /// Requires permission to access the DeleteDimension /// action. /// ///

/// Container for the necessary parameters to execute the DeleteDimension service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDimension service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteDimension Operation public virtual Task DeleteDimensionAsync(DeleteDimensionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDimensionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDimensionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDomainConfiguration internal virtual DeleteDomainConfigurationResponse DeleteDomainConfiguration(DeleteDomainConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDomainConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDomainConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified domain configuration. /// /// /// /// Requires permission to access the DeleteDomainConfiguration /// action. /// ///

/// Container for the necessary parameters to execute the DeleteDomainConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDomainConfiguration service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteDomainConfiguration Operation public virtual Task DeleteDomainConfigurationAsync(DeleteDomainConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDomainConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDomainConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDynamicThingGroup internal virtual DeleteDynamicThingGroupResponse DeleteDynamicThingGroup(DeleteDynamicThingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDynamicThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDynamicThingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a dynamic thing group. /// /// /// /// Requires permission to access the DeleteDynamicThingGroup /// action. /// ///

/// Container for the necessary parameters to execute the DeleteDynamicThingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDynamicThingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteDynamicThingGroup Operation public virtual Task DeleteDynamicThingGroupAsync(DeleteDynamicThingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDynamicThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDynamicThingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteFleetMetric internal virtual DeleteFleetMetricResponse DeleteFleetMetric(DeleteFleetMetricRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteFleetMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteFleetMetricResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteFleetMetric service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteFleetMetric service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteFleetMetric Operation public virtual Task DeleteFleetMetricAsync(DeleteFleetMetricRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteFleetMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteFleetMetricResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteJob internal virtual DeleteJobResponse DeleteJob(DeleteJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteJobRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteJob service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteJob service method, as returned by IoT. /// /// The request is not valid. /// /// /// An attempt was made to change to an invalid state, for example by deleting a job or /// a job execution which is "IN_PROGRESS" without setting the force parameter. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteJob Operation public virtual Task DeleteJobAsync(DeleteJobRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteJobRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteJobResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteJobExecution internal virtual DeleteJobExecutionResponse DeleteJobExecution(DeleteJobExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteJobExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a job execution. /// /// /// /// Requires permission to access the DeleteJobExecution /// action. /// ///

/// Container for the necessary parameters to execute the DeleteJobExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteJobExecution service method, as returned by IoT. /// /// The request is not valid. /// /// /// An attempt was made to change to an invalid state, for example by deleting a job or /// a job execution which is "IN_PROGRESS" without setting the force parameter. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteJobExecution Operation public virtual Task DeleteJobExecutionAsync(DeleteJobExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteJobExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteJobTemplate internal virtual DeleteJobTemplateResponse DeleteJobTemplate(DeleteJobTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteJobTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the specified job template. ///

/// Container for the necessary parameters to execute the DeleteJobTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteJobTemplate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteJobTemplate Operation public virtual Task DeleteJobTemplateAsync(DeleteJobTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteJobTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteMitigationAction internal virtual DeleteMitigationActionResponse DeleteMitigationAction(DeleteMitigationActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMitigationActionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMitigationActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a defined mitigation action from your Amazon Web Services accounts. /// /// /// /// Requires permission to access the DeleteMitigationAction /// action. /// ///

/// Container for the necessary parameters to execute the DeleteMitigationAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteMitigationAction service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteMitigationAction Operation public virtual Task DeleteMitigationActionAsync(DeleteMitigationActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMitigationActionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMitigationActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteOTAUpdate internal virtual DeleteOTAUpdateResponse DeleteOTAUpdate(DeleteOTAUpdateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOTAUpdateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOTAUpdateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Delete an OTA update. /// /// /// /// Requires permission to access the DeleteOTAUpdate /// action. /// ///

/// Container for the necessary parameters to execute the DeleteOTAUpdate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteOTAUpdate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteOTAUpdate Operation public virtual Task DeleteOTAUpdateAsync(DeleteOTAUpdateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOTAUpdateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOTAUpdateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeletePackage internal virtual DeletePackageResponse DeletePackage(DeletePackageRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePackageRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePackageResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeletePackage service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePackage service method, as returned by IoT. /// /// Internal error from the service that indicates an unexpected error or that the service /// is unavailable. /// /// /// The rate exceeds the limit. /// /// /// The request is not valid. /// /// REST API Reference for DeletePackage Operation public virtual Task DeletePackageAsync(DeletePackageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePackageRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePackageResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeletePackageVersion internal virtual DeletePackageVersionResponse DeletePackageVersion(DeletePackageVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePackageVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePackageVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeletePackageVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePackageVersion service method, as returned by IoT. /// /// Internal error from the service that indicates an unexpected error or that the service /// is unavailable. /// /// /// The rate exceeds the limit. /// /// /// The request is not valid. /// /// REST API Reference for DeletePackageVersion Operation public virtual Task DeletePackageVersionAsync(DeletePackageVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePackageVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePackageVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeletePolicy internal virtual DeletePolicyResponse DeletePolicy(DeletePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The name of the policy to delete. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePolicy service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeletePolicy Operation public virtual Task DeletePolicyAsync(string policyName, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeletePolicyRequest(); request.PolicyName = policyName; return DeletePolicyAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DeletePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePolicy service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeletePolicy Operation public virtual Task DeletePolicyAsync(DeletePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeletePolicyVersion internal virtual DeletePolicyVersionResponse DeletePolicyVersion(DeletePolicyVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePolicyVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePolicyVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The name of the policy. /// The policy version ID. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePolicyVersion service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeletePolicyVersion Operation public virtual Task DeletePolicyVersionAsync(string policyName, string policyVersionId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeletePolicyVersionRequest(); request.PolicyName = policyName; request.PolicyVersionId = policyVersionId; return DeletePolicyVersionAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DeletePolicyVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePolicyVersion service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeletePolicyVersion Operation public virtual Task DeletePolicyVersionAsync(DeletePolicyVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePolicyVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePolicyVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteProvisioningTemplate internal virtual DeleteProvisioningTemplateResponse DeleteProvisioningTemplate(DeleteProvisioningTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProvisioningTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProvisioningTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a provisioning template. /// /// /// /// Requires permission to access the DeleteProvisioningTemplate /// action. /// ///

/// Container for the necessary parameters to execute the DeleteProvisioningTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteProvisioningTemplate service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteProvisioningTemplate Operation public virtual Task DeleteProvisioningTemplateAsync(DeleteProvisioningTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProvisioningTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProvisioningTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteProvisioningTemplateVersion internal virtual DeleteProvisioningTemplateVersionResponse DeleteProvisioningTemplateVersion(DeleteProvisioningTemplateVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProvisioningTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProvisioningTemplateVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a provisioning template version. /// /// /// /// Requires permission to access the DeleteProvisioningTemplateVersion /// action. /// ///

/// Container for the necessary parameters to execute the DeleteProvisioningTemplateVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteProvisioningTemplateVersion service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteProvisioningTemplateVersion Operation public virtual Task DeleteProvisioningTemplateVersionAsync(DeleteProvisioningTemplateVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteProvisioningTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteProvisioningTemplateVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteRegistrationCode internal virtual DeleteRegistrationCodeResponse DeleteRegistrationCode(DeleteRegistrationCodeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRegistrationCodeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRegistrationCodeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a CA certificate registration code. /// /// /// /// Requires permission to access the DeleteRegistrationCode /// action. /// ///

/// Container for the necessary parameters to execute the DeleteRegistrationCode service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRegistrationCode service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteRegistrationCode Operation public virtual Task DeleteRegistrationCodeAsync(DeleteRegistrationCodeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRegistrationCodeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRegistrationCodeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteRoleAlias internal virtual DeleteRoleAliasResponse DeleteRoleAlias(DeleteRoleAliasRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRoleAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRoleAliasResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a role alias /// /// /// /// Requires permission to access the DeleteRoleAlias /// action. /// ///

/// Container for the necessary parameters to execute the DeleteRoleAlias service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteRoleAlias service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteRoleAlias Operation public virtual Task DeleteRoleAliasAsync(DeleteRoleAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteRoleAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteRoleAliasResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteScheduledAudit internal virtual DeleteScheduledAuditResponse DeleteScheduledAudit(DeleteScheduledAuditRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteScheduledAuditRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteScheduledAuditResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a scheduled audit. /// /// /// /// Requires permission to access the DeleteScheduledAudit /// action. /// ///

/// Container for the necessary parameters to execute the DeleteScheduledAudit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteScheduledAudit service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DeleteScheduledAudit Operation public virtual Task DeleteScheduledAuditAsync(DeleteScheduledAuditRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteScheduledAuditRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteScheduledAuditResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteSecurityProfile internal virtual DeleteSecurityProfileResponse DeleteSecurityProfile(DeleteSecurityProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSecurityProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a Device Defender security profile. /// /// /// /// Requires permission to access the DeleteSecurityProfile /// action. /// ///

/// Container for the necessary parameters to execute the DeleteSecurityProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSecurityProfile service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteSecurityProfile Operation public virtual Task DeleteSecurityProfileAsync(DeleteSecurityProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSecurityProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteStream internal virtual DeleteStreamResponse DeleteStream(DeleteStreamRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteStreamResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a stream. /// /// /// /// Requires permission to access the DeleteStream /// action. /// ///

/// Container for the necessary parameters to execute the DeleteStream service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteStream service method, as returned by IoT. /// /// You can't delete the resource because it is attached to one or more resources. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteStream Operation public virtual Task DeleteStreamAsync(DeleteStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteStreamResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteThing internal virtual DeleteThingResponse DeleteThing(DeleteThingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteThingRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteThingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The name of the thing to delete. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteThing service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteThing Operation public virtual Task DeleteThingAsync(string thingName, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeleteThingRequest(); request.ThingName = thingName; return DeleteThingAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DeleteThing service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteThing service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteThing Operation public virtual Task DeleteThingAsync(DeleteThingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteThingRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteThingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteThingGroup internal virtual DeleteThingGroupResponse DeleteThingGroup(DeleteThingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteThingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a thing group. /// /// /// /// Requires permission to access the DeleteThingGroup /// action. /// ///

/// Container for the necessary parameters to execute the DeleteThingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteThingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// /// An exception thrown when the version of an entity specified with the expectedVersion /// parameter does not match the latest version in the system. /// /// REST API Reference for DeleteThingGroup Operation public virtual Task DeleteThingGroupAsync(DeleteThingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteThingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteThingType internal virtual DeleteThingTypeResponse DeleteThingType(DeleteThingTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteThingTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DeleteThingType service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteThingType service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteThingType Operation public virtual Task DeleteThingTypeAsync(DeleteThingTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteThingTypeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteTopicRule internal virtual DeleteTopicRuleResponse DeleteTopicRule(DeleteTopicRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTopicRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes the rule. /// /// /// /// Requires permission to access the DeleteTopicRule /// action. /// ///

/// The name of the rule. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTopicRule service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteTopicRule Operation public virtual Task DeleteTopicRuleAsync(string ruleName, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeleteTopicRuleRequest(); request.RuleName = ruleName; return DeleteTopicRuleAsync(request, cancellationToken); } ///

/// Deletes the rule. /// /// /// /// Requires permission to access the DeleteTopicRule /// action. /// ///

/// Container for the necessary parameters to execute the DeleteTopicRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTopicRule service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteTopicRule Operation public virtual Task DeleteTopicRuleAsync(DeleteTopicRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTopicRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteTopicRuleDestination internal virtual DeleteTopicRuleDestinationResponse DeleteTopicRuleDestination(DeleteTopicRuleDestinationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTopicRuleDestinationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTopicRuleDestinationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a topic rule destination. /// /// /// /// Requires permission to access the DeleteTopicRuleDestination /// action. /// ///

/// Container for the necessary parameters to execute the DeleteTopicRuleDestination service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteTopicRuleDestination service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeleteTopicRuleDestination Operation public virtual Task DeleteTopicRuleDestinationAsync(DeleteTopicRuleDestinationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTopicRuleDestinationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTopicRuleDestinationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteV2LoggingLevel internal virtual DeleteV2LoggingLevelResponse DeleteV2LoggingLevel(DeleteV2LoggingLevelRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteV2LoggingLevelRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteV2LoggingLevelResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a logging level. /// /// /// /// Requires permission to access the DeleteV2LoggingLevel /// action. /// ///

/// Container for the necessary parameters to execute the DeleteV2LoggingLevel service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteV2LoggingLevel service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// REST API Reference for DeleteV2LoggingLevel Operation public virtual Task DeleteV2LoggingLevelAsync(DeleteV2LoggingLevelRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteV2LoggingLevelRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteV2LoggingLevelResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeprecateThingType internal virtual DeprecateThingTypeResponse DeprecateThingType(DeprecateThingTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeprecateThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeprecateThingTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deprecates a thing type. You can not associate new things with deprecated thing type. /// /// /// /// Requires permission to access the DeprecateThingType /// action. /// ///

/// Container for the necessary parameters to execute the DeprecateThingType service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeprecateThingType service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DeprecateThingType Operation public virtual Task DeprecateThingTypeAsync(DeprecateThingTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeprecateThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeprecateThingTypeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAccountAuditConfiguration internal virtual DescribeAccountAuditConfigurationResponse DescribeAccountAuditConfiguration(DescribeAccountAuditConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAccountAuditConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAccountAuditConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeAccountAuditConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAccountAuditConfiguration service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeAccountAuditConfiguration Operation public virtual Task DescribeAccountAuditConfigurationAsync(DescribeAccountAuditConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAccountAuditConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAccountAuditConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAuditFinding internal virtual DescribeAuditFindingResponse DescribeAuditFinding(DescribeAuditFindingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditFindingRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditFindingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeAuditFinding service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAuditFinding service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeAuditFinding Operation public virtual Task DescribeAuditFindingAsync(DescribeAuditFindingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditFindingRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditFindingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAuditMitigationActionsTask internal virtual DescribeAuditMitigationActionsTaskResponse DescribeAuditMitigationActionsTask(DescribeAuditMitigationActionsTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditMitigationActionsTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DescribeAuditMitigationActionsTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAuditMitigationActionsTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeAuditMitigationActionsTask Operation public virtual Task DescribeAuditMitigationActionsTaskAsync(DescribeAuditMitigationActionsTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditMitigationActionsTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAuditSuppression internal virtual DescribeAuditSuppressionResponse DescribeAuditSuppression(DescribeAuditSuppressionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditSuppressionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditSuppressionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a Device Defender audit suppression. ///

/// Container for the necessary parameters to execute the DescribeAuditSuppression service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAuditSuppression service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeAuditSuppression Operation public virtual Task DescribeAuditSuppressionAsync(DescribeAuditSuppressionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditSuppressionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditSuppressionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAuditTask internal virtual DescribeAuditTaskResponse DescribeAuditTask(DescribeAuditTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a Device Defender audit. /// /// /// /// Requires permission to access the DescribeAuditTask /// action. /// ///

/// Container for the necessary parameters to execute the DescribeAuditTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAuditTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeAuditTask Operation public virtual Task DescribeAuditTaskAsync(DescribeAuditTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuditTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuditTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAuthorizer internal virtual DescribeAuthorizerResponse DescribeAuthorizer(DescribeAuthorizerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuthorizerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes an authorizer. /// /// /// /// Requires permission to access the DescribeAuthorizer /// action. /// ///

/// Container for the necessary parameters to execute the DescribeAuthorizer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAuthorizer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeAuthorizer Operation public virtual Task DescribeAuthorizerAsync(DescribeAuthorizerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAuthorizerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeBillingGroup internal virtual DescribeBillingGroupResponse DescribeBillingGroup(DescribeBillingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeBillingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about a billing group. /// /// /// /// Requires permission to access the DescribeBillingGroup /// action. /// ///

/// Container for the necessary parameters to execute the DescribeBillingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeBillingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeBillingGroup Operation public virtual Task DescribeBillingGroupAsync(DescribeBillingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeBillingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeBillingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeCACertificate internal virtual DescribeCACertificateResponse DescribeCACertificate(DescribeCACertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCACertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCACertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a registered CA certificate. /// /// /// /// Requires permission to access the DescribeCACertificate /// action. /// ///

/// Container for the necessary parameters to execute the DescribeCACertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCACertificate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeCACertificate Operation public virtual Task DescribeCACertificateAsync(DescribeCACertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCACertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCACertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeCertificate internal virtual DescribeCertificateResponse DescribeCertificate(DescribeCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about the specified certificate. /// /// /// /// Requires permission to access the DescribeCertificate /// action. /// ///

/// The ID of the certificate. (The last part of the certificate ARN contains the certificate ID.) /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCertificate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeCertificate Operation public virtual Task DescribeCertificateAsync(string certificateId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DescribeCertificateRequest(); request.CertificateId = certificateId; return DescribeCertificateAsync(request, cancellationToken); } ///

/// Gets information about the specified certificate. /// /// /// /// Requires permission to access the DescribeCertificate /// action. /// ///

/// Container for the necessary parameters to execute the DescribeCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCertificate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeCertificate Operation public virtual Task DescribeCertificateAsync(DescribeCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeCustomMetric internal virtual DescribeCustomMetricResponse DescribeCustomMetric(DescribeCustomMetricRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCustomMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCustomMetricResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a Device Defender detect custom metric. /// /// /// /// Requires permission to access the DescribeCustomMetric /// action. /// ///

/// Container for the necessary parameters to execute the DescribeCustomMetric service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeCustomMetric service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeCustomMetric Operation public virtual Task DescribeCustomMetricAsync(DescribeCustomMetricRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCustomMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCustomMetricResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDefaultAuthorizer internal virtual DescribeDefaultAuthorizerResponse DescribeDefaultAuthorizer(DescribeDefaultAuthorizerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDefaultAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDefaultAuthorizerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes the default authorizer. /// /// /// /// Requires permission to access the DescribeDefaultAuthorizer /// action. /// ///

/// Container for the necessary parameters to execute the DescribeDefaultAuthorizer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDefaultAuthorizer service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeDefaultAuthorizer Operation public virtual Task DescribeDefaultAuthorizerAsync(DescribeDefaultAuthorizerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDefaultAuthorizerRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDefaultAuthorizerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDetectMitigationActionsTask internal virtual DescribeDetectMitigationActionsTaskResponse DescribeDetectMitigationActionsTask(DescribeDetectMitigationActionsTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDetectMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDetectMitigationActionsTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a Device Defender ML Detect mitigation action. /// /// /// /// Requires permission to access the DescribeDetectMitigationActionsTask /// action. /// ///

/// Container for the necessary parameters to execute the DescribeDetectMitigationActionsTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDetectMitigationActionsTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeDetectMitigationActionsTask Operation public virtual Task DescribeDetectMitigationActionsTaskAsync(DescribeDetectMitigationActionsTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDetectMitigationActionsTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDetectMitigationActionsTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDimension internal virtual DescribeDimensionResponse DescribeDimension(DescribeDimensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDimensionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDimensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Provides details about a dimension that is defined in your Amazon Web Services accounts. /// /// /// /// Requires permission to access the DescribeDimension /// action. /// ///

/// Container for the necessary parameters to execute the DescribeDimension service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDimension service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeDimension Operation public virtual Task DescribeDimensionAsync(DescribeDimensionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDimensionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDimensionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDomainConfiguration internal virtual DescribeDomainConfigurationResponse DescribeDomainConfiguration(DescribeDomainConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDomainConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDomainConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets summary information about a domain configuration. /// /// /// /// Requires permission to access the DescribeDomainConfiguration /// action. /// ///

/// Container for the necessary parameters to execute the DescribeDomainConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDomainConfiguration service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeDomainConfiguration Operation public virtual Task DescribeDomainConfigurationAsync(DescribeDomainConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDomainConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDomainConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEndpoint internal virtual DescribeEndpointResponse DescribeEndpoint(DescribeEndpointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEndpointResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a unique endpoint specific to the Amazon Web Services account making the call. /// /// /// /// Requires permission to access the DescribeEndpoint /// action. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEndpoint service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeEndpoint Operation public virtual Task DescribeEndpointAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DescribeEndpointRequest(); return DescribeEndpointAsync(request, cancellationToken); } ///

/// Returns a unique endpoint specific to the Amazon Web Services account making the call. /// /// /// /// Requires permission to access the DescribeEndpoint /// action. /// ///

/// Container for the necessary parameters to execute the DescribeEndpoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEndpoint service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeEndpoint Operation public virtual Task DescribeEndpointAsync(DescribeEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEndpointRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEndpointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEventConfigurations internal virtual DescribeEventConfigurationsResponse DescribeEventConfigurations(DescribeEventConfigurationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventConfigurationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes event configurations. /// /// /// /// Requires permission to access the DescribeEventConfigurations /// action. /// ///

/// Container for the necessary parameters to execute the DescribeEventConfigurations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEventConfigurations service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeEventConfigurations Operation public virtual Task DescribeEventConfigurationsAsync(DescribeEventConfigurationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventConfigurationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventConfigurationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeFleetMetric internal virtual DescribeFleetMetricResponse DescribeFleetMetric(DescribeFleetMetricRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeFleetMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeFleetMetricResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about the specified fleet metric. /// /// /// /// Requires permission to access the DescribeFleetMetric /// action. /// ///

/// Container for the necessary parameters to execute the DescribeFleetMetric service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeFleetMetric service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeFleetMetric Operation public virtual Task DescribeFleetMetricAsync(DescribeFleetMetricRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeFleetMetricRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeFleetMetricResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeIndex internal virtual DescribeIndexResponse DescribeIndex(DescribeIndexRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeIndexRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeIndexResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a search index. /// /// /// /// Requires permission to access the DescribeIndex /// action. /// ///

/// Container for the necessary parameters to execute the DescribeIndex service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeIndex service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeIndex Operation public virtual Task DescribeIndexAsync(DescribeIndexRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeIndexRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeIndexResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeJob internal virtual DescribeJobResponse DescribeJob(DescribeJobRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeJobRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeJobResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a job. /// /// /// /// Requires permission to access the DescribeJob /// action. /// ///

/// Container for the necessary parameters to execute the DescribeJob service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeJob service method, as returned by IoT. /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeJob Operation public virtual Task DescribeJobAsync(DescribeJobRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeJobRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeJobResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeJobExecution internal virtual DescribeJobExecutionResponse DescribeJobExecution(DescribeJobExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeJobExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a job execution. /// /// /// /// Requires permission to access the DescribeJobExecution /// action. /// ///

/// Container for the necessary parameters to execute the DescribeJobExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeJobExecution service method, as returned by IoT. /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeJobExecution Operation public virtual Task DescribeJobExecutionAsync(DescribeJobExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeJobExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeJobExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeJobTemplate internal virtual DescribeJobTemplateResponse DescribeJobTemplate(DescribeJobTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeJobTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about a job template. ///

/// Container for the necessary parameters to execute the DescribeJobTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeJobTemplate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeJobTemplate Operation public virtual Task DescribeJobTemplateAsync(DescribeJobTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeJobTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeManagedJobTemplate internal virtual DescribeManagedJobTemplateResponse DescribeManagedJobTemplate(DescribeManagedJobTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeManagedJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeManagedJobTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// View details of a managed job template. ///

/// Container for the necessary parameters to execute the DescribeManagedJobTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeManagedJobTemplate service method, as returned by IoT. /// /// Internal error from the service that indicates an unexpected error or that the service /// is unavailable. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeManagedJobTemplate Operation public virtual Task DescribeManagedJobTemplateAsync(DescribeManagedJobTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeManagedJobTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeManagedJobTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMitigationAction internal virtual DescribeMitigationActionResponse DescribeMitigationAction(DescribeMitigationActionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMitigationActionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMitigationActionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a mitigation action. /// /// /// /// Requires permission to access the DescribeMitigationAction /// action. /// ///

/// Container for the necessary parameters to execute the DescribeMitigationAction service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMitigationAction service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeMitigationAction Operation public virtual Task DescribeMitigationActionAsync(DescribeMitigationActionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMitigationActionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMitigationActionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeProvisioningTemplate internal virtual DescribeProvisioningTemplateResponse DescribeProvisioningTemplate(DescribeProvisioningTemplateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeProvisioningTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeProvisioningTemplateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about a provisioning template. /// /// /// /// Requires permission to access the DescribeProvisioningTemplate /// action. /// ///

/// Container for the necessary parameters to execute the DescribeProvisioningTemplate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeProvisioningTemplate service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeProvisioningTemplate Operation public virtual Task DescribeProvisioningTemplateAsync(DescribeProvisioningTemplateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeProvisioningTemplateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeProvisioningTemplateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeProvisioningTemplateVersion internal virtual DescribeProvisioningTemplateVersionResponse DescribeProvisioningTemplateVersion(DescribeProvisioningTemplateVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeProvisioningTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeProvisioningTemplateVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns information about a provisioning template version. /// /// /// /// Requires permission to access the DescribeProvisioningTemplateVersion /// action. /// ///

/// Container for the necessary parameters to execute the DescribeProvisioningTemplateVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeProvisioningTemplateVersion service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeProvisioningTemplateVersion Operation public virtual Task DescribeProvisioningTemplateVersionAsync(DescribeProvisioningTemplateVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeProvisioningTemplateVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeProvisioningTemplateVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeRoleAlias internal virtual DescribeRoleAliasResponse DescribeRoleAlias(DescribeRoleAliasRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRoleAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRoleAliasResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a role alias. /// /// /// /// Requires permission to access the DescribeRoleAlias /// action. /// ///

/// Container for the necessary parameters to execute the DescribeRoleAlias service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeRoleAlias service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeRoleAlias Operation public virtual Task DescribeRoleAliasAsync(DescribeRoleAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRoleAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRoleAliasResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeScheduledAudit internal virtual DescribeScheduledAuditResponse DescribeScheduledAudit(DescribeScheduledAuditRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeScheduledAuditRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeScheduledAuditResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a scheduled audit. /// /// /// /// Requires permission to access the DescribeScheduledAudit /// action. /// ///

/// Container for the necessary parameters to execute the DescribeScheduledAudit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeScheduledAudit service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeScheduledAudit Operation public virtual Task DescribeScheduledAuditAsync(DescribeScheduledAuditRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeScheduledAuditRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeScheduledAuditResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSecurityProfile internal virtual DescribeSecurityProfileResponse DescribeSecurityProfile(DescribeSecurityProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSecurityProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a Device Defender security profile. /// /// /// /// Requires permission to access the DescribeSecurityProfile /// action. /// ///

/// Container for the necessary parameters to execute the DescribeSecurityProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSecurityProfile service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeSecurityProfile Operation public virtual Task DescribeSecurityProfileAsync(DescribeSecurityProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSecurityProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeStream internal virtual DescribeStreamResponse DescribeStream(DescribeStreamRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeStreamResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about a stream. /// /// /// /// Requires permission to access the DescribeStream /// action. /// ///

/// Container for the necessary parameters to execute the DescribeStream service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeStream service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeStream Operation public virtual Task DescribeStreamAsync(DescribeStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeStreamRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeStreamResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeThing internal virtual DescribeThingResponse DescribeThing(DescribeThingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about the specified thing. /// /// /// /// Requires permission to access the DescribeThing /// action. /// ///

/// The name of the thing. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeThing service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeThing Operation public virtual Task DescribeThingAsync(string thingName, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DescribeThingRequest(); request.ThingName = thingName; return DescribeThingAsync(request, cancellationToken); } ///

/// Gets information about the specified thing. /// /// /// /// Requires permission to access the DescribeThing /// action. /// ///

/// Container for the necessary parameters to execute the DescribeThing service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeThing service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeThing Operation public virtual Task DescribeThingAsync(DescribeThingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeThingGroup internal virtual DescribeThingGroupResponse DescribeThingGroup(DescribeThingGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describe a thing group. /// /// /// /// Requires permission to access the DescribeThingGroup /// action. /// ///

/// Container for the necessary parameters to execute the DescribeThingGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeThingGroup service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DescribeThingGroup Operation public virtual Task DescribeThingGroupAsync(DescribeThingGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeThingRegistrationTask internal virtual DescribeThingRegistrationTaskResponse DescribeThingRegistrationTask(DescribeThingRegistrationTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingRegistrationTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingRegistrationTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a bulk thing provisioning task. /// /// /// /// Requires permission to access the DescribeThingRegistrationTask /// action. /// ///

/// Container for the necessary parameters to execute the DescribeThingRegistrationTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeThingRegistrationTask service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeThingRegistrationTask Operation public virtual Task DescribeThingRegistrationTaskAsync(DescribeThingRegistrationTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingRegistrationTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingRegistrationTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeThingType internal virtual DescribeThingTypeResponse DescribeThingType(DescribeThingTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets information about the specified thing type. /// /// /// /// Requires permission to access the DescribeThingType /// action. /// ///

/// Container for the necessary parameters to execute the DescribeThingType service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeThingType service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DescribeThingType Operation public virtual Task DescribeThingTypeAsync(DescribeThingTypeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeThingTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeThingTypeResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DetachPolicy internal virtual DetachPolicyResponse DetachPolicy(DetachPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DetachPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachPolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DetachPolicy Operation public virtual Task DetachPolicyAsync(DetachPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DetachPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DetachPrincipalPolicy [Obsolete("Deprecated in favor of DetachPolicy.")] internal virtual DetachPrincipalPolicyResponse DetachPrincipalPolicy(DetachPrincipalPolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachPrincipalPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachPrincipalPolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes the specified policy from the specified certificate. /// /// /// /// Note: This action is deprecated and works as expected for backward compatibility, /// but we won't add enhancements. Use DetachPolicy instead. /// /// /// /// Requires permission to access the DetachPrincipalPolicy /// action. /// ///

/// The name of the policy to detach. /// The principal. Valid principals are CertificateArn (arn:aws:iot:region:accountId:cert/certificateId), thingGroupArn (arn:aws:iot:region:accountId:thinggroup/groupName) and CognitoId (region:id). /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachPrincipalPolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DetachPrincipalPolicy Operation [Obsolete("Deprecated in favor of DetachPolicy.")] public virtual Task DetachPrincipalPolicyAsync(string policyName, string principal, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DetachPrincipalPolicyRequest(); request.PolicyName = policyName; request.Principal = principal; return DetachPrincipalPolicyAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DetachPrincipalPolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachPrincipalPolicy service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DetachPrincipalPolicy Operation [Obsolete("Deprecated in favor of DetachPolicy.")] public virtual Task DetachPrincipalPolicyAsync(DetachPrincipalPolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DetachPrincipalPolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachPrincipalPolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DetachSecurityProfile internal virtual DetachSecurityProfileResponse DetachSecurityProfile(DetachSecurityProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachSecurityProfileResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Disassociates a Device Defender security profile from a thing group or from this account. /// /// /// /// Requires permission to access the DetachSecurityProfile /// action. /// ///

/// Container for the necessary parameters to execute the DetachSecurityProfile service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachSecurityProfile service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for DetachSecurityProfile Operation public virtual Task DetachSecurityProfileAsync(DetachSecurityProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DetachSecurityProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachSecurityProfileResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DetachThingPrincipal internal virtual DetachThingPrincipalResponse DetachThingPrincipal(DetachThingPrincipalRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DetachThingPrincipalRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachThingPrincipalResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The name of the thing. /// If the principal is a certificate, this value must be ARN of the certificate. If the principal is an Amazon Cognito identity, this value must be the ID of the Amazon Cognito identity. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachThingPrincipal service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DetachThingPrincipal Operation public virtual Task DetachThingPrincipalAsync(string thingName, string principal, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DetachThingPrincipalRequest(); request.ThingName = thingName; request.Principal = principal; return DetachThingPrincipalAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DetachThingPrincipal service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DetachThingPrincipal service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DetachThingPrincipal Operation public virtual Task DetachThingPrincipalAsync(DetachThingPrincipalRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DetachThingPrincipalRequestMarshaller.Instance; options.ResponseUnmarshaller = DetachThingPrincipalResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableTopicRule internal virtual DisableTopicRuleResponse DisableTopicRule(DisableTopicRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableTopicRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Disables the rule. /// /// /// /// Requires permission to access the DisableTopicRule /// action. /// ///

/// Container for the necessary parameters to execute the DisableTopicRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DisableTopicRule service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for DisableTopicRule Operation public virtual Task DisableTopicRuleAsync(DisableTopicRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableTopicRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableTopicRule internal virtual EnableTopicRuleResponse EnableTopicRule(EnableTopicRuleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableTopicRuleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Enables the rule. /// /// /// /// Requires permission to access the EnableTopicRule /// action. /// ///

/// Container for the necessary parameters to execute the EnableTopicRule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the EnableTopicRule service method, as returned by IoT. /// /// A conflicting resource update exception. This exception is thrown when two pending /// updates cause a conflict. /// /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for EnableTopicRule Operation public virtual Task EnableTopicRuleAsync(EnableTopicRuleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableTopicRuleRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableTopicRuleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetBehaviorModelTrainingSummaries internal virtual GetBehaviorModelTrainingSummariesResponse GetBehaviorModelTrainingSummaries(GetBehaviorModelTrainingSummariesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBehaviorModelTrainingSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBehaviorModelTrainingSummariesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a Device Defender's ML Detect Security Profile training model's status. /// /// /// /// Requires permission to access the GetBehaviorModelTrainingSummaries /// action. /// ///

/// Container for the necessary parameters to execute the GetBehaviorModelTrainingSummaries service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetBehaviorModelTrainingSummaries service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The rate exceeds the limit. /// /// REST API Reference for GetBehaviorModelTrainingSummaries Operation public virtual Task GetBehaviorModelTrainingSummariesAsync(GetBehaviorModelTrainingSummariesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetBehaviorModelTrainingSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBehaviorModelTrainingSummariesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetBucketsAggregation internal virtual GetBucketsAggregationResponse GetBucketsAggregation(GetBucketsAggregationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketsAggregationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketsAggregationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Aggregates on indexed data with search queries pertaining to particular fields. /// /// /// /// Requires permission to access the GetBucketsAggregation /// action. /// ///

/// Container for the necessary parameters to execute the GetBucketsAggregation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetBucketsAggregation service method, as returned by IoT. /// /// The index is not ready. /// /// /// An unexpected error has occurred. /// /// /// The aggregation is invalid. /// /// /// The query is invalid. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for GetBucketsAggregation Operation public virtual Task GetBucketsAggregationAsync(GetBucketsAggregationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetBucketsAggregationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetBucketsAggregationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetCardinality internal virtual GetCardinalityResponse GetCardinality(GetCardinalityRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCardinalityRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCardinalityResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns the approximate count of unique values that match the query. /// /// /// /// Requires permission to access the GetCardinality /// action. /// ///

/// Container for the necessary parameters to execute the GetCardinality service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetCardinality service method, as returned by IoT. /// /// The index is not ready. /// /// /// An unexpected error has occurred. /// /// /// The aggregation is invalid. /// /// /// The query is invalid. /// /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for GetCardinality Operation public virtual Task GetCardinalityAsync(GetCardinalityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetCardinalityRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCardinalityResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetEffectivePolicies internal virtual GetEffectivePoliciesResponse GetEffectivePolicies(GetEffectivePoliciesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetEffectivePoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEffectivePoliciesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetEffectivePolicies service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetEffectivePolicies service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// A limit has been exceeded. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for GetEffectivePolicies Operation public virtual Task GetEffectivePoliciesAsync(GetEffectivePoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetEffectivePoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEffectivePoliciesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetIndexingConfiguration internal virtual GetIndexingConfigurationResponse GetIndexingConfiguration(GetIndexingConfigurationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetIndexingConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetIndexingConfigurationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets the indexing configuration. /// /// /// /// Requires permission to access the GetIndexingConfiguration /// action. /// ///

/// Container for the necessary parameters to execute the GetIndexingConfiguration service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetIndexingConfiguration service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// /// You are not authorized to perform this operation. /// /// REST API Reference for GetIndexingConfiguration Operation public virtual Task GetIndexingConfigurationAsync(GetIndexingConfigurationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetIndexingConfigurationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetIndexingConfigurationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetJobDocument internal virtual GetJobDocumentResponse GetJobDocument(GetJobDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetJobDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetJobDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets a job document. /// /// /// /// Requires permission to access the GetJobDocument /// action. /// ///

/// Container for the necessary parameters to execute the GetJobDocument service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetJobDocument service method, as returned by IoT. /// /// The request is not valid. /// /// /// The specified resource does not exist. /// /// /// The service is temporarily unavailable. /// /// /// The rate exceeds the limit. /// /// REST API Reference for GetJobDocument Operation public virtual Task GetJobDocumentAsync(GetJobDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetJobDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetJobDocumentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetLoggingOptions internal virtual GetLoggingOptionsResponse GetLoggingOptions(GetLoggingOptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoggingOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoggingOptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Gets the logging options. /// /// /// /// NOTE: use of this command is not recommended. Use GetV2LoggingOptions /// instead. /// /// /// /// Requires permission to access the /// action. /// ///

/// Container for the necessary parameters to execute the GetLoggingOptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetLoggingOptions service method, as returned by IoT. /// /// An unexpected error has occurred. /// /// /// The request is not valid. /// /// /// The service is temporarily unavailable. /// /// REST API Reference for GetLoggingOptions Operation public virtual Task GetLoggingOptionsAsync(GetLoggingOptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetLoggingOptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetLoggingOptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetOTAUpdate internal virtual GetOTAUpdateResponse GetOTAUpdate(GetOTAUpdateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOTAUpdateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOTAUpdateResponseUnmarshaller.Instance; return Invoke