Documentation

Overview

    Package iot provides the API client, operations, and parameter types for AWS IoT.

    AWS IoT AWS IoT provides secure, bi-directional communication between Internet-connected devices (such as sensors, actuators, embedded devices, or smart appliances) and the AWS 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 AWS IoT Core Endpoints and Quotas (https://docs.aws.amazon.com/general/latest/gr/iot-core.html). You must use the endpoint for the region that has the resources you want to access. The service name used by AWS Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) to sign the request is: execute-api. For more information about how AWS IoT works, see the Developer Guide (https://docs.aws.amazon.com/iot/latest/developerguide/aws-iot-how-it-works.html). For information about how to use the credentials provider for AWS IoT, see Authorizing Direct Calls to AWS Services (https://docs.aws.amazon.com/iot/latest/developerguide/authorizing-direct-aws.html).

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2015-05-28"
    View Source
    const ServiceID = "IoT"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type AcceptCertificateTransferInput

          type AcceptCertificateTransferInput struct {
          
          	// The ID of the certificate. (The last part of the certificate ARN contains the
          	// certificate ID.)
          	//
          	// This member is required.
          	CertificateId *string
          
          	// Specifies whether the certificate is active.
          	SetAsActive bool
          }

            The input for the AcceptCertificateTransfer operation.

            type AcceptCertificateTransferOutput

            type AcceptCertificateTransferOutput struct {
            	// Metadata pertaining to the operation's result.
            	ResultMetadata middleware.Metadata
            }

            type AddThingToBillingGroupInput

            type AddThingToBillingGroupInput struct {
            
            	// The ARN of the billing group.
            	BillingGroupArn *string
            
            	// The name of the billing group.
            	BillingGroupName *string
            
            	// The ARN of the thing to be added to the billing group.
            	ThingArn *string
            
            	// The name of the thing to be added to the billing group.
            	ThingName *string
            }

            type AddThingToBillingGroupOutput

            type AddThingToBillingGroupOutput struct {
            	// Metadata pertaining to the operation's result.
            	ResultMetadata middleware.Metadata
            }

            type AddThingToThingGroupInput

            type AddThingToThingGroupInput struct {
            
            	// Override dynamic thing groups with static thing groups when 10-group limit is
            	// reached. If a thing belongs to 10 thing groups, and one or more of those groups
            	// are dynamic thing groups, adding a thing to a static group removes the thing
            	// from the last dynamic group.
            	OverrideDynamicGroups bool
            
            	// The ARN of the thing to add to a group.
            	ThingArn *string
            
            	// The ARN of the group to which you are adding a thing.
            	ThingGroupArn *string
            
            	// The name of the group to which you are adding a thing.
            	ThingGroupName *string
            
            	// The name of the thing to add to a group.
            	ThingName *string
            }

            type AddThingToThingGroupOutput

            type AddThingToThingGroupOutput struct {
            	// Metadata pertaining to the operation's result.
            	ResultMetadata middleware.Metadata
            }

            type AssociateTargetsWithJobInput

            type AssociateTargetsWithJobInput struct {
            
            	// The unique identifier you assigned to this job when it was created.
            	//
            	// This member is required.
            	JobId *string
            
            	// A list of thing group ARNs that define the targets of the job.
            	//
            	// This member is required.
            	Targets []string
            
            	// An optional comment string describing why the job was associated with the
            	// targets.
            	Comment *string
            
            	// The namespace used to indicate that a job is a customer-managed job. When you
            	// specify a value for this parameter, AWS IoT Core sends jobs notifications to
            	// MQTT topics that contain the value in the following format.
            	// $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/ The
            	// namespaceId feature is in public preview.
            	NamespaceId *string
            }

            type AssociateTargetsWithJobOutput

            type AssociateTargetsWithJobOutput struct {
            
            	// A short text description of the job.
            	Description *string
            
            	// An ARN identifying the job.
            	JobArn *string
            
            	// The unique identifier you assigned to this job when it was created.
            	JobId *string
            
            	// Metadata pertaining to the operation's result.
            	ResultMetadata middleware.Metadata
            }

            type AttachPolicyInput

            type AttachPolicyInput struct {
            
            	// The name of the policy to attach.
            	//
            	// This member is required.
            	PolicyName *string
            
            	// The identity
            	// (https://docs.aws.amazon.com/iot/latest/developerguide/security-iam.html) to
            	// which the policy is attached.
            	//
            	// This member is required.
            	Target *string
            }

            type AttachPolicyOutput

            type AttachPolicyOutput struct {
            	// Metadata pertaining to the operation's result.
            	ResultMetadata middleware.Metadata
            }

            type AttachPrincipalPolicyInput

            type AttachPrincipalPolicyInput struct {
            
            	// The policy name.
            	//
            	// This member is required.
            	PolicyName *string
            
            	// The principal, which can be a certificate ARN (as returned from the
            	// CreateCertificate operation) or an Amazon Cognito ID.
            	//
            	// This member is required.
            	Principal *string
            }

              The input for the AttachPrincipalPolicy operation.

              type AttachPrincipalPolicyOutput

              type AttachPrincipalPolicyOutput struct {
              	// Metadata pertaining to the operation's result.
              	ResultMetadata middleware.Metadata
              }

              type AttachSecurityProfileInput

              type AttachSecurityProfileInput struct {
              
              	// The security profile that is attached.
              	//
              	// This member is required.
              	SecurityProfileName *string
              
              	// The ARN of the target (thing group) to which the security profile is attached.
              	//
              	// This member is required.
              	SecurityProfileTargetArn *string
              }

              type AttachSecurityProfileOutput

              type AttachSecurityProfileOutput struct {
              	// Metadata pertaining to the operation's result.
              	ResultMetadata middleware.Metadata
              }

              type AttachThingPrincipalInput

              type AttachThingPrincipalInput struct {
              
              	// The principal, which can be a certificate ARN (as returned from the
              	// CreateCertificate operation) or an Amazon Cognito ID.
              	//
              	// This member is required.
              	Principal *string
              
              	// The name of the thing.
              	//
              	// This member is required.
              	ThingName *string
              }

                The input for the AttachThingPrincipal operation.

                type AttachThingPrincipalOutput

                type AttachThingPrincipalOutput struct {
                	// Metadata pertaining to the operation's result.
                	ResultMetadata middleware.Metadata
                }

                  The output from the AttachThingPrincipal operation.

                  type CancelAuditMitigationActionsTaskInput

                  type CancelAuditMitigationActionsTaskInput struct {
                  
                  	// The unique identifier for the task that you want to cancel.
                  	//
                  	// This member is required.
                  	TaskId *string
                  }

                  type CancelAuditMitigationActionsTaskOutput

                  type CancelAuditMitigationActionsTaskOutput struct {
                  	// Metadata pertaining to the operation's result.
                  	ResultMetadata middleware.Metadata
                  }

                  type CancelAuditTaskInput

                  type CancelAuditTaskInput struct {
                  
                  	// The ID of the audit you want to cancel. You can only cancel an audit that is
                  	// "IN_PROGRESS".
                  	//
                  	// This member is required.
                  	TaskId *string
                  }

                  type CancelAuditTaskOutput

                  type CancelAuditTaskOutput struct {
                  	// Metadata pertaining to the operation's result.
                  	ResultMetadata middleware.Metadata
                  }

                  type CancelCertificateTransferInput

                  type CancelCertificateTransferInput struct {
                  
                  	// The ID of the certificate. (The last part of the certificate ARN contains the
                  	// certificate ID.)
                  	//
                  	// This member is required.
                  	CertificateId *string
                  }

                    The input for the CancelCertificateTransfer operation.

                    type CancelCertificateTransferOutput

                    type CancelCertificateTransferOutput struct {
                    	// Metadata pertaining to the operation's result.
                    	ResultMetadata middleware.Metadata
                    }

                    type CancelJobExecutionInput

                    type CancelJobExecutionInput struct {
                    
                    	// The ID of the job to be canceled.
                    	//
                    	// This member is required.
                    	JobId *string
                    
                    	// The name of the thing whose execution of the job will be canceled.
                    	//
                    	// This member is required.
                    	ThingName *string
                    
                    	// (Optional) The expected current version of the job execution. Each time you
                    	// update the job execution, its version is incremented. If the version of the job
                    	// execution stored in Jobs does not match, the update is rejected with a
                    	// VersionMismatch error, and an ErrorResponse that contains the current job
                    	// execution status data is returned. (This makes it unnecessary to perform a
                    	// separate DescribeJobExecution request in order to obtain the job execution
                    	// status data.)
                    	ExpectedVersion *int64
                    
                    	// (Optional) If true the job execution will be canceled if it has status
                    	// IN_PROGRESS or QUEUED, otherwise the job execution will be canceled only if it
                    	// has status QUEUED. If you attempt to cancel a job execution that is IN_PROGRESS,
                    	// and you do not set force to true, then an InvalidStateTransitionException will
                    	// be thrown. The default is false. Canceling a job execution which is
                    	// "IN_PROGRESS", will cause the device to be unable to update the job execution
                    	// status. Use caution and ensure that the device is able to recover to a valid
                    	// state.
                    	Force bool
                    
                    	// A collection of name/value pairs that describe the status of the job execution.
                    	// If not specified, the statusDetails are unchanged. You can specify at most 10
                    	// name/value pairs.
                    	StatusDetails map[string]string
                    }

                    type CancelJobExecutionOutput

                    type CancelJobExecutionOutput struct {
                    	// Metadata pertaining to the operation's result.
                    	ResultMetadata middleware.Metadata
                    }

                    type CancelJobInput

                    type CancelJobInput struct {
                    
                    	// The unique identifier you assigned to this job when it was created.
                    	//
                    	// This member is required.
                    	JobId *string
                    
                    	// An optional comment string describing why the job was canceled.
                    	Comment *string
                    
                    	// (Optional) If true job executions with status "IN_PROGRESS" and "QUEUED" are
                    	// canceled, otherwise only job executions with status "QUEUED" are canceled. The
                    	// default is false. Canceling a job which is "IN_PROGRESS", will cause a device
                    	// which is executing the job to be unable to update the job execution status. Use
                    	// caution and ensure that each device executing a job which is canceled is able to
                    	// recover to a valid state.
                    	Force bool
                    
                    	// (Optional)A reason code string that explains why the job was canceled.
                    	ReasonCode *string
                    }

                    type CancelJobOutput

                    type CancelJobOutput struct {
                    
                    	// A short text description of the job.
                    	Description *string
                    
                    	// The job ARN.
                    	JobArn *string
                    
                    	// The unique identifier you assigned to this job when it was created.
                    	JobId *string
                    
                    	// Metadata pertaining to the operation's result.
                    	ResultMetadata middleware.Metadata
                    }

                    type ClearDefaultAuthorizerInput

                    type ClearDefaultAuthorizerInput struct {
                    }

                    type ClearDefaultAuthorizerOutput

                    type ClearDefaultAuthorizerOutput struct {
                    	// Metadata pertaining to the operation's result.
                    	ResultMetadata middleware.Metadata
                    }

                    type Client

                    type Client struct {
                    	// contains filtered or unexported fields
                    }

                      Client provides the API client to make operations call for AWS IoT.

                      func New

                      func New(options Options, optFns ...func(*Options)) *Client

                        New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

                        func NewFromConfig

                        func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                          NewFromConfig returns a new client from the provided config.

                          func (*Client) AcceptCertificateTransfer

                          func (c *Client) AcceptCertificateTransfer(ctx context.Context, params *AcceptCertificateTransferInput, optFns ...func(*Options)) (*AcceptCertificateTransferOutput, error)

                            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.

                            func (*Client) AddThingToBillingGroup

                            func (c *Client) AddThingToBillingGroup(ctx context.Context, params *AddThingToBillingGroupInput, optFns ...func(*Options)) (*AddThingToBillingGroupOutput, error)

                              Adds a thing to a billing group.

                              func (*Client) AddThingToThingGroup

                              func (c *Client) AddThingToThingGroup(ctx context.Context, params *AddThingToThingGroupInput, optFns ...func(*Options)) (*AddThingToThingGroupOutput, error)

                                Adds a thing to a thing group.

                                func (*Client) AssociateTargetsWithJob

                                func (c *Client) AssociateTargetsWithJob(ctx context.Context, params *AssociateTargetsWithJobInput, optFns ...func(*Options)) (*AssociateTargetsWithJobOutput, error)

                                  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.

                                  func (*Client) AttachPolicy

                                  func (c *Client) AttachPolicy(ctx context.Context, params *AttachPolicyInput, optFns ...func(*Options)) (*AttachPolicyOutput, error)

                                    Attaches a policy to the specified target.

                                    func (*Client) AttachPrincipalPolicy

                                    func (c *Client) AttachPrincipalPolicy(ctx context.Context, params *AttachPrincipalPolicyInput, optFns ...func(*Options)) (*AttachPrincipalPolicyOutput, error)

                                      Attaches the specified policy to the specified principal (certificate or other credential). Note: This API is deprecated. Please use AttachPolicy instead.

                                      Deprecated: This operation has been deprecated.

                                      func (*Client) AttachSecurityProfile

                                      func (c *Client) AttachSecurityProfile(ctx context.Context, params *AttachSecurityProfileInput, optFns ...func(*Options)) (*AttachSecurityProfileOutput, error)

                                        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.

                                        func (*Client) AttachThingPrincipal

                                        func (c *Client) AttachThingPrincipal(ctx context.Context, params *AttachThingPrincipalInput, optFns ...func(*Options)) (*AttachThingPrincipalOutput, error)

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

                                          func (*Client) CancelAuditMitigationActionsTask

                                          func (c *Client) CancelAuditMitigationActionsTask(ctx context.Context, params *CancelAuditMitigationActionsTaskInput, optFns ...func(*Options)) (*CancelAuditMitigationActionsTaskOutput, error)

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

                                            func (*Client) CancelAuditTask

                                            func (c *Client) CancelAuditTask(ctx context.Context, params *CancelAuditTaskInput, optFns ...func(*Options)) (*CancelAuditTaskOutput, error)

                                              Cancels an audit that is in progress. The audit can be either scheduled or on-demand. If the audit is not in progress, an "InvalidRequestException" occurs.

                                              func (*Client) CancelCertificateTransfer

                                              func (c *Client) CancelCertificateTransfer(ctx context.Context, params *CancelCertificateTransferInput, optFns ...func(*Options)) (*CancelCertificateTransferOutput, error)

                                                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, AWS 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.

                                                func (*Client) CancelJob

                                                func (c *Client) CancelJob(ctx context.Context, params *CancelJobInput, optFns ...func(*Options)) (*CancelJobOutput, error)

                                                  Cancels a job.

                                                  func (*Client) CancelJobExecution

                                                  func (c *Client) CancelJobExecution(ctx context.Context, params *CancelJobExecutionInput, optFns ...func(*Options)) (*CancelJobExecutionOutput, error)

                                                    Cancels the execution of a job for a given thing.

                                                    func (*Client) ClearDefaultAuthorizer

                                                    func (c *Client) ClearDefaultAuthorizer(ctx context.Context, params *ClearDefaultAuthorizerInput, optFns ...func(*Options)) (*ClearDefaultAuthorizerOutput, error)

                                                      Clears the default authorizer.

                                                      func (*Client) ConfirmTopicRuleDestination

                                                      func (c *Client) ConfirmTopicRuleDestination(ctx context.Context, params *ConfirmTopicRuleDestinationInput, optFns ...func(*Options)) (*ConfirmTopicRuleDestinationOutput, error)

                                                        Confirms a topic rule destination. When you create a rule requiring a destination, AWS 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.

                                                        func (*Client) CreateAuditSuppression

                                                        func (c *Client) CreateAuditSuppression(ctx context.Context, params *CreateAuditSuppressionInput, optFns ...func(*Options)) (*CreateAuditSuppressionOutput, error)

                                                          Creates a Device Defender audit suppression.

                                                          func (*Client) CreateAuthorizer

                                                          func (c *Client) CreateAuthorizer(ctx context.Context, params *CreateAuthorizerInput, optFns ...func(*Options)) (*CreateAuthorizerOutput, error)

                                                            Creates an authorizer.

                                                            func (*Client) CreateBillingGroup

                                                            func (c *Client) CreateBillingGroup(ctx context.Context, params *CreateBillingGroupInput, optFns ...func(*Options)) (*CreateBillingGroupOutput, error)

                                                              Creates a billing group.

                                                              func (*Client) CreateCertificateFromCsr

                                                              func (c *Client) CreateCertificateFromCsr(ctx context.Context, params *CreateCertificateFromCsrInput, optFns ...func(*Options)) (*CreateCertificateFromCsrOutput, error)

                                                                Creates an X.509 certificate using the specified certificate signing request. Note: 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. Note: 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. Assuming 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 AWS CLI command to create a certificate for the corresponding CSR. The aws iot create-certificate-from-csr part of the command can also be run 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"

                                                                func (*Client) CreateDimension

                                                                func (c *Client) CreateDimension(ctx context.Context, params *CreateDimensionInput, optFns ...func(*Options)) (*CreateDimensionOutput, error)

                                                                  Create a dimension that you can use to limit the scope of a metric used in a security profile for AWS 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.

                                                                  func (*Client) CreateDomainConfiguration

                                                                  func (c *Client) CreateDomainConfiguration(ctx context.Context, params *CreateDomainConfigurationInput, optFns ...func(*Options)) (*CreateDomainConfigurationOutput, error)

                                                                    Creates a domain configuration. The domain configuration feature is in public preview and is subject to change.

                                                                    func (*Client) CreateDynamicThingGroup

                                                                    func (c *Client) CreateDynamicThingGroup(ctx context.Context, params *CreateDynamicThingGroupInput, optFns ...func(*Options)) (*CreateDynamicThingGroupOutput, error)

                                                                      Creates a dynamic thing group.

                                                                      func (*Client) CreateJob

                                                                      func (c *Client) CreateJob(ctx context.Context, params *CreateJobInput, optFns ...func(*Options)) (*CreateJobOutput, error)

                                                                        Creates a job.

                                                                        func (*Client) CreateKeysAndCertificate

                                                                        func (c *Client) CreateKeysAndCertificate(ctx context.Context, params *CreateKeysAndCertificateInput, optFns ...func(*Options)) (*CreateKeysAndCertificateOutput, error)

                                                                          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 (https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html#provision-mqtt-api). Note This is the only time AWS IoT issues the private key for this certificate, so it is important to keep it in a secure location.

                                                                          func (*Client) CreateMitigationAction

                                                                          func (c *Client) CreateMitigationAction(ctx context.Context, params *CreateMitigationActionInput, optFns ...func(*Options)) (*CreateMitigationActionOutput, error)

                                                                            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 (https://docs.aws.amazon.com/iot/latest/developerguide/device-defender-mitigation-actions.html). Each mitigation action can apply only one type of change.

                                                                            func (*Client) CreateOTAUpdate

                                                                            func (c *Client) CreateOTAUpdate(ctx context.Context, params *CreateOTAUpdateInput, optFns ...func(*Options)) (*CreateOTAUpdateOutput, error)

                                                                              Creates an AWS IoT OTAUpdate on a target group of things or groups.

                                                                              func (*Client) CreatePolicy

                                                                              func (c *Client) CreatePolicy(ctx context.Context, params *CreatePolicyInput, optFns ...func(*Options)) (*CreatePolicyOutput, error)

                                                                                Creates an AWS 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.

                                                                                func (*Client) CreatePolicyVersion

                                                                                func (c *Client) CreatePolicyVersion(ctx context.Context, params *CreatePolicyVersionInput, optFns ...func(*Options)) (*CreatePolicyVersionOutput, error)

                                                                                  Creates a new version of the specified AWS 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).

                                                                                  func (*Client) CreateProvisioningClaim

                                                                                  func (c *Client) CreateProvisioningClaim(ctx context.Context, params *CreateProvisioningClaimInput, optFns ...func(*Options)) (*CreateProvisioningClaimOutput, error)

                                                                                    Creates a provisioning claim.

                                                                                    func (*Client) CreateProvisioningTemplate

                                                                                    func (c *Client) CreateProvisioningTemplate(ctx context.Context, params *CreateProvisioningTemplateInput, optFns ...func(*Options)) (*CreateProvisioningTemplateOutput, error)

                                                                                      Creates a fleet provisioning template.

                                                                                      func (*Client) CreateProvisioningTemplateVersion

                                                                                      func (c *Client) CreateProvisioningTemplateVersion(ctx context.Context, params *CreateProvisioningTemplateVersionInput, optFns ...func(*Options)) (*CreateProvisioningTemplateVersionOutput, error)

                                                                                        Creates a new version of a fleet provisioning template.

                                                                                        func (*Client) CreateRoleAlias

                                                                                        func (c *Client) CreateRoleAlias(ctx context.Context, params *CreateRoleAliasInput, optFns ...func(*Options)) (*CreateRoleAliasOutput, error)

                                                                                          Creates a role alias.

                                                                                          func (*Client) CreateScheduledAudit

                                                                                          func (c *Client) CreateScheduledAudit(ctx context.Context, params *CreateScheduledAuditInput, optFns ...func(*Options)) (*CreateScheduledAuditOutput, error)

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

                                                                                            func (*Client) CreateSecurityProfile

                                                                                            func (c *Client) CreateSecurityProfile(ctx context.Context, params *CreateSecurityProfileInput, optFns ...func(*Options)) (*CreateSecurityProfileOutput, error)

                                                                                              Creates a Device Defender security profile.

                                                                                              func (*Client) CreateStream

                                                                                              func (c *Client) CreateStream(ctx context.Context, params *CreateStreamInput, optFns ...func(*Options)) (*CreateStreamOutput, error)

                                                                                                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.

                                                                                                func (*Client) CreateThing

                                                                                                func (c *Client) CreateThing(ctx context.Context, params *CreateThingInput, optFns ...func(*Options)) (*CreateThingOutput, error)

                                                                                                  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 (https://docs.aws.amazon.com/iot/latest/developerguide/iot-authorization.html) for information about authorizing control plane actions.

                                                                                                  func (*Client) CreateThingGroup

                                                                                                  func (c *Client) CreateThingGroup(ctx context.Context, params *CreateThingGroupInput, optFns ...func(*Options)) (*CreateThingGroupOutput, error)

                                                                                                    Create a thing group. This is a control plane operation. See Authorization (https://docs.aws.amazon.com/iot/latest/developerguide/iot-authorization.html) for information about authorizing control plane actions.

                                                                                                    func (*Client) CreateThingType

                                                                                                    func (c *Client) CreateThingType(ctx context.Context, params *CreateThingTypeInput, optFns ...func(*Options)) (*CreateThingTypeOutput, error)

                                                                                                      Creates a new thing type.

                                                                                                      func (*Client) CreateTopicRule

                                                                                                      func (c *Client) CreateTopicRule(ctx context.Context, params *CreateTopicRuleInput, optFns ...func(*Options)) (*CreateTopicRuleOutput, error)

                                                                                                        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.

                                                                                                        func (*Client) CreateTopicRuleDestination

                                                                                                        func (c *Client) CreateTopicRuleDestination(ctx context.Context, params *CreateTopicRuleDestinationInput, optFns ...func(*Options)) (*CreateTopicRuleDestinationOutput, error)

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

                                                                                                          func (*Client) DeleteAccountAuditConfiguration

                                                                                                          func (c *Client) DeleteAccountAuditConfiguration(ctx context.Context, params *DeleteAccountAuditConfigurationInput, optFns ...func(*Options)) (*DeleteAccountAuditConfigurationOutput, error)

                                                                                                            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.

                                                                                                            func (*Client) DeleteAuditSuppression

                                                                                                            func (c *Client) DeleteAuditSuppression(ctx context.Context, params *DeleteAuditSuppressionInput, optFns ...func(*Options)) (*DeleteAuditSuppressionOutput, error)

                                                                                                              Deletes a Device Defender audit suppression.

                                                                                                              func (*Client) DeleteAuthorizer

                                                                                                              func (c *Client) DeleteAuthorizer(ctx context.Context, params *DeleteAuthorizerInput, optFns ...func(*Options)) (*DeleteAuthorizerOutput, error)

                                                                                                                Deletes an authorizer.

                                                                                                                func (*Client) DeleteBillingGroup

                                                                                                                func (c *Client) DeleteBillingGroup(ctx context.Context, params *DeleteBillingGroupInput, optFns ...func(*Options)) (*DeleteBillingGroupOutput, error)

                                                                                                                  Deletes the billing group.

                                                                                                                  func (*Client) DeleteCACertificate

                                                                                                                  func (c *Client) DeleteCACertificate(ctx context.Context, params *DeleteCACertificateInput, optFns ...func(*Options)) (*DeleteCACertificateOutput, error)

                                                                                                                    Deletes a registered CA certificate.

                                                                                                                    func (*Client) DeleteCertificate

                                                                                                                    func (c *Client) DeleteCertificate(ctx context.Context, params *DeleteCertificateInput, optFns ...func(*Options)) (*DeleteCertificateOutput, error)

                                                                                                                      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 DetachPrincipalPolicy API to detach all policies. Next, use the UpdateCertificate API to set the certificate to the INACTIVE status.

                                                                                                                      func (*Client) DeleteDimension

                                                                                                                      func (c *Client) DeleteDimension(ctx context.Context, params *DeleteDimensionInput, optFns ...func(*Options)) (*DeleteDimensionOutput, error)

                                                                                                                        Removes the specified dimension from your AWS account.

                                                                                                                        func (*Client) DeleteDomainConfiguration

                                                                                                                        func (c *Client) DeleteDomainConfiguration(ctx context.Context, params *DeleteDomainConfigurationInput, optFns ...func(*Options)) (*DeleteDomainConfigurationOutput, error)

                                                                                                                          Deletes the specified domain configuration. The domain configuration feature is in public preview and is subject to change.

                                                                                                                          func (*Client) DeleteDynamicThingGroup

                                                                                                                          func (c *Client) DeleteDynamicThingGroup(ctx context.Context, params *DeleteDynamicThingGroupInput, optFns ...func(*Options)) (*DeleteDynamicThingGroupOutput, error)

                                                                                                                            Deletes a dynamic thing group.

                                                                                                                            func (*Client) DeleteJob

                                                                                                                            func (c *Client) DeleteJob(ctx context.Context, params *DeleteJobInput, optFns ...func(*Options)) (*DeleteJobOutput, error)

                                                                                                                              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.

                                                                                                                              func (*Client) DeleteJobExecution

                                                                                                                              func (c *Client) DeleteJobExecution(ctx context.Context, params *DeleteJobExecutionInput, optFns ...func(*Options)) (*DeleteJobExecutionOutput, error)

                                                                                                                                Deletes a job execution.

                                                                                                                                func (*Client) DeleteMitigationAction

                                                                                                                                func (c *Client) DeleteMitigationAction(ctx context.Context, params *DeleteMitigationActionInput, optFns ...func(*Options)) (*DeleteMitigationActionOutput, error)

                                                                                                                                  Deletes a defined mitigation action from your AWS account.

                                                                                                                                  func (*Client) DeleteOTAUpdate

                                                                                                                                  func (c *Client) DeleteOTAUpdate(ctx context.Context, params *DeleteOTAUpdateInput, optFns ...func(*Options)) (*DeleteOTAUpdateOutput, error)

                                                                                                                                    Delete an OTA update.

                                                                                                                                    func (*Client) DeletePolicy

                                                                                                                                    func (c *Client) DeletePolicy(ctx context.Context, params *DeletePolicyInput, optFns ...func(*Options)) (*DeletePolicyOutput, error)

                                                                                                                                      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 API to delete all non-default versions of the policy; use the DetachPrincipalPolicy API to detach the policy from any certificate; and then use the DeletePolicy API to delete the policy. When a policy is deleted using DeletePolicy, its default version is deleted with it.

                                                                                                                                      func (*Client) DeletePolicyVersion

                                                                                                                                      func (c *Client) DeletePolicyVersion(ctx context.Context, params *DeletePolicyVersionInput, optFns ...func(*Options)) (*DeletePolicyVersionOutput, error)

                                                                                                                                        Deletes the specified version of the specified policy. You cannot delete the default version of a policy using this API. 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.

                                                                                                                                        func (*Client) DeleteProvisioningTemplate

                                                                                                                                        func (c *Client) DeleteProvisioningTemplate(ctx context.Context, params *DeleteProvisioningTemplateInput, optFns ...func(*Options)) (*DeleteProvisioningTemplateOutput, error)

                                                                                                                                          Deletes a fleet provisioning template.

                                                                                                                                          func (*Client) DeleteProvisioningTemplateVersion

                                                                                                                                          func (c *Client) DeleteProvisioningTemplateVersion(ctx context.Context, params *DeleteProvisioningTemplateVersionInput, optFns ...func(*Options)) (*DeleteProvisioningTemplateVersionOutput, error)

                                                                                                                                            Deletes a fleet provisioning template version.

                                                                                                                                            func (*Client) DeleteRegistrationCode

                                                                                                                                            func (c *Client) DeleteRegistrationCode(ctx context.Context, params *DeleteRegistrationCodeInput, optFns ...func(*Options)) (*DeleteRegistrationCodeOutput, error)

                                                                                                                                              Deletes a CA certificate registration code.

                                                                                                                                              func (*Client) DeleteRoleAlias

                                                                                                                                              func (c *Client) DeleteRoleAlias(ctx context.Context, params *DeleteRoleAliasInput, optFns ...func(*Options)) (*DeleteRoleAliasOutput, error)

                                                                                                                                                Deletes a role alias

                                                                                                                                                func (*Client) DeleteScheduledAudit

                                                                                                                                                func (c *Client) DeleteScheduledAudit(ctx context.Context, params *DeleteScheduledAuditInput, optFns ...func(*Options)) (*DeleteScheduledAuditOutput, error)

                                                                                                                                                  Deletes a scheduled audit.

                                                                                                                                                  func (*Client) DeleteSecurityProfile

                                                                                                                                                  func (c *Client) DeleteSecurityProfile(ctx context.Context, params *DeleteSecurityProfileInput, optFns ...func(*Options)) (*DeleteSecurityProfileOutput, error)

                                                                                                                                                    Deletes a Device Defender security profile.

                                                                                                                                                    func (*Client) DeleteStream

                                                                                                                                                    func (c *Client) DeleteStream(ctx context.Context, params *DeleteStreamInput, optFns ...func(*Options)) (*DeleteStreamOutput, error)

                                                                                                                                                      Deletes a stream.

                                                                                                                                                      func (*Client) DeleteThing

                                                                                                                                                      func (c *Client) DeleteThing(ctx context.Context, params *DeleteThingInput, optFns ...func(*Options)) (*DeleteThingOutput, error)

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

                                                                                                                                                        func (*Client) DeleteThingGroup

                                                                                                                                                        func (c *Client) DeleteThingGroup(ctx context.Context, params *DeleteThingGroupInput, optFns ...func(*Options)) (*DeleteThingGroupOutput, error)

                                                                                                                                                          Deletes a thing group.

                                                                                                                                                          func (*Client) DeleteThingType

                                                                                                                                                          func (c *Client) DeleteThingType(ctx context.Context, params *DeleteThingTypeInput, optFns ...func(*Options)) (*DeleteThingTypeOutput, error)

                                                                                                                                                            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.

                                                                                                                                                            func (*Client) DeleteTopicRule

                                                                                                                                                            func (c *Client) DeleteTopicRule(ctx context.Context, params *DeleteTopicRuleInput, optFns ...func(*Options)) (*DeleteTopicRuleOutput, error)

                                                                                                                                                              Deletes the rule.

                                                                                                                                                              func (*Client) DeleteTopicRuleDestination

                                                                                                                                                              func (c *Client) DeleteTopicRuleDestination(ctx context.Context, params *DeleteTopicRuleDestinationInput, optFns ...func(*Options)) (*DeleteTopicRuleDestinationOutput, error)

                                                                                                                                                                Deletes a topic rule destination.

                                                                                                                                                                func (*Client) DeleteV2LoggingLevel

                                                                                                                                                                func (c *Client) DeleteV2LoggingLevel(ctx context.Context, params *DeleteV2LoggingLevelInput, optFns ...func(*Options)) (*DeleteV2LoggingLevelOutput, error)

                                                                                                                                                                  Deletes a logging level.

                                                                                                                                                                  func (*Client) DeprecateThingType

                                                                                                                                                                  func (c *Client) DeprecateThingType(ctx context.Context, params *DeprecateThingTypeInput, optFns ...func(*Options)) (*DeprecateThingTypeOutput, error)

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

                                                                                                                                                                    func (*Client) DescribeAccountAuditConfiguration

                                                                                                                                                                    func (c *Client) DescribeAccountAuditConfiguration(ctx context.Context, params *DescribeAccountAuditConfigurationInput, optFns ...func(*Options)) (*DescribeAccountAuditConfigurationOutput, error)

                                                                                                                                                                      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.

                                                                                                                                                                      func (*Client) DescribeAuditFinding

                                                                                                                                                                      func (c *Client) DescribeAuditFinding(ctx context.Context, params *DescribeAuditFindingInput, optFns ...func(*Options)) (*DescribeAuditFindingOutput, error)

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

                                                                                                                                                                        func (*Client) DescribeAuditMitigationActionsTask

                                                                                                                                                                        func (c *Client) DescribeAuditMitigationActionsTask(ctx context.Context, params *DescribeAuditMitigationActionsTaskInput, optFns ...func(*Options)) (*DescribeAuditMitigationActionsTaskOutput, error)

                                                                                                                                                                          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.

                                                                                                                                                                          func (*Client) DescribeAuditSuppression

                                                                                                                                                                          func (c *Client) DescribeAuditSuppression(ctx context.Context, params *DescribeAuditSuppressionInput, optFns ...func(*Options)) (*DescribeAuditSuppressionOutput, error)

                                                                                                                                                                            Gets information about a Device Defender audit suppression.

                                                                                                                                                                            func (*Client) DescribeAuditTask

                                                                                                                                                                            func (c *Client) DescribeAuditTask(ctx context.Context, params *DescribeAuditTaskInput, optFns ...func(*Options)) (*DescribeAuditTaskOutput, error)

                                                                                                                                                                              Gets information about a Device Defender audit.

                                                                                                                                                                              func (*Client) DescribeAuthorizer

                                                                                                                                                                              func (c *Client) DescribeAuthorizer(ctx context.Context, params *DescribeAuthorizerInput, optFns ...func(*Options)) (*DescribeAuthorizerOutput, error)

                                                                                                                                                                                Describes an authorizer.

                                                                                                                                                                                func (*Client) DescribeBillingGroup

                                                                                                                                                                                func (c *Client) DescribeBillingGroup(ctx context.Context, params *DescribeBillingGroupInput, optFns ...func(*Options)) (*DescribeBillingGroupOutput, error)

                                                                                                                                                                                  Returns information about a billing group.

                                                                                                                                                                                  func (*Client) DescribeCACertificate

                                                                                                                                                                                  func (c *Client) DescribeCACertificate(ctx context.Context, params *DescribeCACertificateInput, optFns ...func(*Options)) (*DescribeCACertificateOutput, error)

                                                                                                                                                                                    Describes a registered CA certificate.

                                                                                                                                                                                    func (*Client) DescribeCertificate

                                                                                                                                                                                    func (c *Client) DescribeCertificate(ctx context.Context, params *DescribeCertificateInput, optFns ...func(*Options)) (*DescribeCertificateOutput, error)

                                                                                                                                                                                      Gets information about the specified certificate.

                                                                                                                                                                                      func (*Client) DescribeDefaultAuthorizer

                                                                                                                                                                                      func (c *Client) DescribeDefaultAuthorizer(ctx context.Context, params *DescribeDefaultAuthorizerInput, optFns ...func(*Options)) (*DescribeDefaultAuthorizerOutput, error)

                                                                                                                                                                                        Describes the default authorizer.

                                                                                                                                                                                        func (*Client) DescribeDimension

                                                                                                                                                                                        func (c *Client) DescribeDimension(ctx context.Context, params *DescribeDimensionInput, optFns ...func(*Options)) (*DescribeDimensionOutput, error)

                                                                                                                                                                                          Provides details about a dimension that is defined in your AWS account.

                                                                                                                                                                                          func (*Client) DescribeDomainConfiguration

                                                                                                                                                                                          func (c *Client) DescribeDomainConfiguration(ctx context.Context, params *DescribeDomainConfigurationInput, optFns ...func(*Options)) (*DescribeDomainConfigurationOutput, error)

                                                                                                                                                                                            Gets summary information about a domain configuration. The domain configuration feature is in public preview and is subject to change.

                                                                                                                                                                                            func (*Client) DescribeEndpoint

                                                                                                                                                                                            func (c *Client) DescribeEndpoint(ctx context.Context, params *DescribeEndpointInput, optFns ...func(*Options)) (*DescribeEndpointOutput, error)

                                                                                                                                                                                              Returns a unique endpoint specific to the AWS account making the call.

                                                                                                                                                                                              func (*Client) DescribeEventConfigurations

                                                                                                                                                                                              func (c *Client) DescribeEventConfigurations(ctx context.Context, params *DescribeEventConfigurationsInput, optFns ...func(*Options)) (*DescribeEventConfigurationsOutput, error)

                                                                                                                                                                                                Describes event configurations.

                                                                                                                                                                                                func (*Client) DescribeIndex

                                                                                                                                                                                                func (c *Client) DescribeIndex(ctx context.Context, params *DescribeIndexInput, optFns ...func(*Options)) (*DescribeIndexOutput, error)

                                                                                                                                                                                                  Describes a search index.

                                                                                                                                                                                                  func (*Client) DescribeJob

                                                                                                                                                                                                  func (c *Client) DescribeJob(ctx context.Context, params *DescribeJobInput, optFns ...func(*Options)) (*DescribeJobOutput, error)

                                                                                                                                                                                                    Describes a job.

                                                                                                                                                                                                    func (*Client) DescribeJobExecution

                                                                                                                                                                                                    func (c *Client) DescribeJobExecution(ctx context.Context, params *DescribeJobExecutionInput, optFns ...func(*Options)) (*DescribeJobExecutionOutput, error)

                                                                                                                                                                                                      Describes a job execution.

                                                                                                                                                                                                      func (*Client) DescribeMitigationAction

                                                                                                                                                                                                      func (c *Client) DescribeMitigationAction(ctx context.Context, params *DescribeMitigationActionInput, optFns ...func(*Options)) (*DescribeMitigationActionOutput, error)

                                                                                                                                                                                                        Gets information about a mitigation action.

                                                                                                                                                                                                        func (*Client) DescribeProvisioningTemplate

                                                                                                                                                                                                        func (c *Client) DescribeProvisioningTemplate(ctx context.Context, params *DescribeProvisioningTemplateInput, optFns ...func(*Options)) (*DescribeProvisioningTemplateOutput, error)

                                                                                                                                                                                                          Returns information about a fleet provisioning template.

                                                                                                                                                                                                          func (*Client) DescribeProvisioningTemplateVersion

                                                                                                                                                                                                          func (c *Client) DescribeProvisioningTemplateVersion(ctx context.Context, params *DescribeProvisioningTemplateVersionInput, optFns ...func(*Options)) (*DescribeProvisioningTemplateVersionOutput, error)

                                                                                                                                                                                                            Returns information about a fleet provisioning template version.

                                                                                                                                                                                                            func (*Client) DescribeRoleAlias

                                                                                                                                                                                                            func (c *Client) DescribeRoleAlias(ctx context.Context, params *DescribeRoleAliasInput, optFns ...func(*Options)) (*DescribeRoleAliasOutput, error)

                                                                                                                                                                                                              Describes a role alias.

                                                                                                                                                                                                              func (*Client) DescribeScheduledAudit

                                                                                                                                                                                                              func (c *Client) DescribeScheduledAudit(ctx context.Context, params *DescribeScheduledAuditInput, optFns ...func(*Options)) (*DescribeScheduledAuditOutput, error)

                                                                                                                                                                                                                Gets information about a scheduled audit.

                                                                                                                                                                                                                func (*Client) DescribeSecurityProfile

                                                                                                                                                                                                                func (c *Client) DescribeSecurityProfile(ctx context.Context, params *DescribeSecurityProfileInput, optFns ...func(*Options)) (*DescribeSecurityProfileOutput, error)

                                                                                                                                                                                                                  Gets information about a Device Defender security profile.

                                                                                                                                                                                                                  func (*Client) DescribeStream

                                                                                                                                                                                                                  func (c *Client) DescribeStream(ctx context.Context, params *DescribeStreamInput, optFns ...func(*Options)) (*DescribeStreamOutput, error)

                                                                                                                                                                                                                    Gets information about a stream.

                                                                                                                                                                                                                    func (*Client) DescribeThing

                                                                                                                                                                                                                    func (c *Client) DescribeThing(ctx context.Context, params *DescribeThingInput, optFns ...func(*Options)) (*DescribeThingOutput, error)

                                                                                                                                                                                                                      Gets information about the specified thing.

                                                                                                                                                                                                                      func (*Client) DescribeThingGroup

                                                                                                                                                                                                                      func (c *Client) DescribeThingGroup(ctx context.Context, params *DescribeThingGroupInput, optFns ...func(*Options)) (*DescribeThingGroupOutput, error)

                                                                                                                                                                                                                        Describe a thing group.

                                                                                                                                                                                                                        func (*Client) DescribeThingRegistrationTask

                                                                                                                                                                                                                        func (c *Client) DescribeThingRegistrationTask(ctx context.Context, params *DescribeThingRegistrationTaskInput, optFns ...func(*Options)) (*DescribeThingRegistrationTaskOutput, error)

                                                                                                                                                                                                                          Describes a bulk thing provisioning task.

                                                                                                                                                                                                                          func (*Client) DescribeThingType

                                                                                                                                                                                                                          func (c *Client) DescribeThingType(ctx context.Context, params *DescribeThingTypeInput, optFns ...func(*Options)) (*DescribeThingTypeOutput, error)

                                                                                                                                                                                                                            Gets information about the specified thing type.

                                                                                                                                                                                                                            func (*Client) DetachPolicy

                                                                                                                                                                                                                            func (c *Client) DetachPolicy(ctx context.Context, params *DetachPolicyInput, optFns ...func(*Options)) (*DetachPolicyOutput, error)

                                                                                                                                                                                                                              Detaches a policy from the specified target.

                                                                                                                                                                                                                              func (*Client) DetachPrincipalPolicy

                                                                                                                                                                                                                              func (c *Client) DetachPrincipalPolicy(ctx context.Context, params *DetachPrincipalPolicyInput, optFns ...func(*Options)) (*DetachPrincipalPolicyOutput, error)

                                                                                                                                                                                                                                Removes the specified policy from the specified certificate. Note: This API is deprecated. Please use DetachPolicy instead.

                                                                                                                                                                                                                                Deprecated: This operation has been deprecated.

                                                                                                                                                                                                                                func (*Client) DetachSecurityProfile

                                                                                                                                                                                                                                func (c *Client) DetachSecurityProfile(ctx context.Context, params *DetachSecurityProfileInput, optFns ...func(*Options)) (*DetachSecurityProfileOutput, error)

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

                                                                                                                                                                                                                                  func (*Client) DetachThingPrincipal

                                                                                                                                                                                                                                  func (c *Client) DetachThingPrincipal(ctx context.Context, params *DetachThingPrincipalInput, optFns ...func(*Options)) (*DetachThingPrincipalOutput, error)

                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                    func (*Client) DisableTopicRule

                                                                                                                                                                                                                                    func (c *Client) DisableTopicRule(ctx context.Context, params *DisableTopicRuleInput, optFns ...func(*Options)) (*DisableTopicRuleOutput, error)

                                                                                                                                                                                                                                      Disables the rule.

                                                                                                                                                                                                                                      func (*Client) EnableTopicRule

                                                                                                                                                                                                                                      func (c *Client) EnableTopicRule(ctx context.Context, params *EnableTopicRuleInput, optFns ...func(*Options)) (*EnableTopicRuleOutput, error)

                                                                                                                                                                                                                                        Enables the rule.

                                                                                                                                                                                                                                        func (*Client) GetCardinality

                                                                                                                                                                                                                                        func (c *Client) GetCardinality(ctx context.Context, params *GetCardinalityInput, optFns ...func(*Options)) (*GetCardinalityOutput, error)

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

                                                                                                                                                                                                                                          func (*Client) GetEffectivePolicies

                                                                                                                                                                                                                                          func (c *Client) GetEffectivePolicies(ctx context.Context, params *GetEffectivePoliciesInput, optFns ...func(*Options)) (*GetEffectivePoliciesOutput, error)

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

                                                                                                                                                                                                                                            func (*Client) GetIndexingConfiguration

                                                                                                                                                                                                                                            func (c *Client) GetIndexingConfiguration(ctx context.Context, params *GetIndexingConfigurationInput, optFns ...func(*Options)) (*GetIndexingConfigurationOutput, error)

                                                                                                                                                                                                                                              Gets the indexing configuration.

                                                                                                                                                                                                                                              func (*Client) GetJobDocument

                                                                                                                                                                                                                                              func (c *Client) GetJobDocument(ctx context.Context, params *GetJobDocumentInput, optFns ...func(*Options)) (*GetJobDocumentOutput, error)

                                                                                                                                                                                                                                                Gets a job document.

                                                                                                                                                                                                                                                func (*Client) GetLoggingOptions

                                                                                                                                                                                                                                                func (c *Client) GetLoggingOptions(ctx context.Context, params *GetLoggingOptionsInput, optFns ...func(*Options)) (*GetLoggingOptionsOutput, error)

                                                                                                                                                                                                                                                  Gets the logging options. NOTE: use of this command is not recommended. Use GetV2LoggingOptions instead.

                                                                                                                                                                                                                                                  func (*Client) GetOTAUpdate

                                                                                                                                                                                                                                                  func (c *Client) GetOTAUpdate(ctx context.Context, params *GetOTAUpdateInput, optFns ...func(*Options)) (*GetOTAUpdateOutput, error)

                                                                                                                                                                                                                                                    Gets an OTA update.

                                                                                                                                                                                                                                                    func (*Client) GetPercentiles

                                                                                                                                                                                                                                                    func (c *Client) GetPercentiles(ctx context.Context, params *GetPercentilesInput, optFns ...func(*Options)) (*GetPercentilesOutput, error)

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

                                                                                                                                                                                                                                                      func (*Client) GetPolicy

                                                                                                                                                                                                                                                      func (c *Client) GetPolicy(ctx context.Context, params *GetPolicyInput, optFns ...func(*Options)) (*GetPolicyOutput, error)

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

                                                                                                                                                                                                                                                        func (*Client) GetPolicyVersion

                                                                                                                                                                                                                                                        func (c *Client) GetPolicyVersion(ctx context.Context, params *GetPolicyVersionInput, optFns ...func(*Options)) (*GetPolicyVersionOutput, error)

                                                                                                                                                                                                                                                          Gets information about the specified policy version.

                                                                                                                                                                                                                                                          func (*Client) GetRegistrationCode

                                                                                                                                                                                                                                                          func (c *Client) GetRegistrationCode(ctx context.Context, params *GetRegistrationCodeInput, optFns ...func(*Options)) (*GetRegistrationCodeOutput, error)

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

                                                                                                                                                                                                                                                            func (*Client) GetStatistics

                                                                                                                                                                                                                                                            func (c *Client) GetStatistics(ctx context.Context, params *GetStatisticsInput, optFns ...func(*Options)) (*GetStatisticsOutput, error)

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

                                                                                                                                                                                                                                                              func (*Client) GetTopicRule

                                                                                                                                                                                                                                                              func (c *Client) GetTopicRule(ctx context.Context, params *GetTopicRuleInput, optFns ...func(*Options)) (*GetTopicRuleOutput, error)

                                                                                                                                                                                                                                                                Gets information about the rule.

                                                                                                                                                                                                                                                                func (*Client) GetTopicRuleDestination

                                                                                                                                                                                                                                                                func (c *Client) GetTopicRuleDestination(ctx context.Context, params *GetTopicRuleDestinationInput, optFns ...func(*Options)) (*GetTopicRuleDestinationOutput, error)

                                                                                                                                                                                                                                                                  Gets information about a topic rule destination.

                                                                                                                                                                                                                                                                  func (*Client) GetV2LoggingOptions

                                                                                                                                                                                                                                                                  func (c *Client) GetV2LoggingOptions(ctx context.Context, params *GetV2LoggingOptionsInput, optFns ...func(*Options)) (*GetV2LoggingOptionsOutput, error)

                                                                                                                                                                                                                                                                    Gets the fine grained logging options.

                                                                                                                                                                                                                                                                    func (*Client) ListActiveViolations

                                                                                                                                                                                                                                                                    func (c *Client) ListActiveViolations(ctx context.Context, params *ListActiveViolationsInput, optFns ...func(*Options)) (*ListActiveViolationsOutput, error)

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

                                                                                                                                                                                                                                                                      func (*Client) ListAttachedPolicies

                                                                                                                                                                                                                                                                      func (c *Client) ListAttachedPolicies(ctx context.Context, params *ListAttachedPoliciesInput, optFns ...func(*Options)) (*ListAttachedPoliciesOutput, error)

                                                                                                                                                                                                                                                                        Lists the policies attached to the specified thing group.

                                                                                                                                                                                                                                                                        func (*Client) ListAuditFindings

                                                                                                                                                                                                                                                                        func (c *Client) ListAuditFindings(ctx context.Context, params *ListAuditFindingsInput, optFns ...func(*Options)) (*ListAuditFindingsOutput, error)

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

                                                                                                                                                                                                                                                                          func (*Client) ListAuditMitigationActionsExecutions

                                                                                                                                                                                                                                                                          func (c *Client) ListAuditMitigationActionsExecutions(ctx context.Context, params *ListAuditMitigationActionsExecutionsInput, optFns ...func(*Options)) (*ListAuditMitigationActionsExecutionsOutput, error)

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

                                                                                                                                                                                                                                                                            func (*Client) ListAuditMitigationActionsTasks

                                                                                                                                                                                                                                                                            func (c *Client) ListAuditMitigationActionsTasks(ctx context.Context, params *ListAuditMitigationActionsTasksInput, optFns ...func(*Options)) (*ListAuditMitigationActionsTasksOutput, error)

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

                                                                                                                                                                                                                                                                              func (*Client) ListAuditSuppressions

                                                                                                                                                                                                                                                                              func (c *Client) ListAuditSuppressions(ctx context.Context, params *ListAuditSuppressionsInput, optFns ...func(*Options)) (*ListAuditSuppressionsOutput, error)

                                                                                                                                                                                                                                                                                Lists your Device Defender audit listings.

                                                                                                                                                                                                                                                                                func (*Client) ListAuditTasks

                                                                                                                                                                                                                                                                                func (c *Client) ListAuditTasks(ctx context.Context, params *ListAuditTasksInput, optFns ...func(*Options)) (*ListAuditTasksOutput, error)

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

                                                                                                                                                                                                                                                                                  func (*Client) ListAuthorizers

                                                                                                                                                                                                                                                                                  func (c *Client) ListAuthorizers(ctx context.Context, params *ListAuthorizersInput, optFns ...func(*Options)) (*ListAuthorizersOutput, error)

                                                                                                                                                                                                                                                                                    Lists the authorizers registered in your account.

                                                                                                                                                                                                                                                                                    func (*Client) ListBillingGroups

                                                                                                                                                                                                                                                                                    func (c *Client) ListBillingGroups(ctx context.Context, params *ListBillingGroupsInput, optFns ...func(*Options)) (*ListBillingGroupsOutput, error)

                                                                                                                                                                                                                                                                                      Lists the billing groups you have created.

                                                                                                                                                                                                                                                                                      func (*Client) ListCACertificates

                                                                                                                                                                                                                                                                                      func (c *Client) ListCACertificates(ctx context.Context, params *ListCACertificatesInput, optFns ...func(*Options)) (*ListCACertificatesOutput, error)

                                                                                                                                                                                                                                                                                        Lists the CA certificates registered for your AWS account. The results are paginated with a default page size of 25. You can use the returned marker to retrieve additional results.

                                                                                                                                                                                                                                                                                        func (*Client) ListCertificates

                                                                                                                                                                                                                                                                                        func (c *Client) ListCertificates(ctx context.Context, params *ListCertificatesInput, optFns ...func(*Options)) (*ListCertificatesOutput, error)

                                                                                                                                                                                                                                                                                          Lists the certificates registered in your AWS account. The results are paginated with a default page size of 25. You can use the returned marker to retrieve additional results.

                                                                                                                                                                                                                                                                                          func (*Client) ListCertificatesByCA

                                                                                                                                                                                                                                                                                          func (c *Client) ListCertificatesByCA(ctx context.Context, params *ListCertificatesByCAInput, optFns ...func(*Options)) (*ListCertificatesByCAOutput, error)

                                                                                                                                                                                                                                                                                            List the device certificates signed by the specified CA certificate.

                                                                                                                                                                                                                                                                                            func (*Client) ListDimensions

                                                                                                                                                                                                                                                                                            func (c *Client) ListDimensions(ctx context.Context, params *ListDimensionsInput, optFns ...func(*Options)) (*ListDimensionsOutput, error)

                                                                                                                                                                                                                                                                                              List the set of dimensions that are defined for your AWS account.

                                                                                                                                                                                                                                                                                              func (*Client) ListDomainConfigurations

                                                                                                                                                                                                                                                                                              func (c *Client) ListDomainConfigurations(ctx context.Context, params *ListDomainConfigurationsInput, optFns ...func(*Options)) (*ListDomainConfigurationsOutput, error)

                                                                                                                                                                                                                                                                                                Gets a list of domain configurations for the user. This list is sorted alphabetically by domain configuration name. The domain configuration feature is in public preview and is subject to change.

                                                                                                                                                                                                                                                                                                func (*Client) ListIndices

                                                                                                                                                                                                                                                                                                func (c *Client) ListIndices(ctx context.Context, params *ListIndicesInput, optFns ...func(*Options)) (*ListIndicesOutput, error)

                                                                                                                                                                                                                                                                                                  Lists the search indices.

                                                                                                                                                                                                                                                                                                  func (*Client) ListJobExecutionsForJob

                                                                                                                                                                                                                                                                                                  func (c *Client) ListJobExecutionsForJob(ctx context.Context, params *ListJobExecutionsForJobInput, optFns ...func(*Options)) (*ListJobExecutionsForJobOutput, error)

                                                                                                                                                                                                                                                                                                    Lists the job executions for a job.

                                                                                                                                                                                                                                                                                                    func (*Client) ListJobExecutionsForThing

                                                                                                                                                                                                                                                                                                    func (c *Client) ListJobExecutionsForThing(ctx context.Context, params *ListJobExecutionsForThingInput, optFns ...func(*Options)) (*ListJobExecutionsForThingOutput, error)

                                                                                                                                                                                                                                                                                                      Lists the job executions for the specified thing.

                                                                                                                                                                                                                                                                                                      func (*Client) ListJobs

                                                                                                                                                                                                                                                                                                      func (c *Client) ListJobs(ctx context.Context, params *ListJobsInput, optFns ...func(*Options)) (*ListJobsOutput, error)

                                                                                                                                                                                                                                                                                                        Lists jobs.

                                                                                                                                                                                                                                                                                                        func (*Client) ListMitigationActions

                                                                                                                                                                                                                                                                                                        func (c *Client) ListMitigationActions(ctx context.Context, params *ListMitigationActionsInput, optFns ...func(*Options)) (*ListMitigationActionsOutput, error)

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

                                                                                                                                                                                                                                                                                                          func (*Client) ListOTAUpdates

                                                                                                                                                                                                                                                                                                          func (c *Client) ListOTAUpdates(ctx context.Context, params *ListOTAUpdatesInput, optFns ...func(*Options)) (*ListOTAUpdatesOutput, error)

                                                                                                                                                                                                                                                                                                            Lists OTA updates.

                                                                                                                                                                                                                                                                                                            func (*Client) ListOutgoingCertificates

                                                                                                                                                                                                                                                                                                            func (c *Client) ListOutgoingCertificates(ctx context.Context, params *ListOutgoingCertificatesInput, optFns ...func(*Options)) (*ListOutgoingCertificatesOutput, error)

                                                                                                                                                                                                                                                                                                              Lists certificates that are being transferred but not yet accepted.

                                                                                                                                                                                                                                                                                                              func (*Client) ListPolicies

                                                                                                                                                                                                                                                                                                              func (c *Client) ListPolicies(ctx context.Context, params *ListPoliciesInput, optFns ...func(*Options)) (*ListPoliciesOutput, error)

                                                                                                                                                                                                                                                                                                                Lists your policies.

                                                                                                                                                                                                                                                                                                                func (*Client) ListPolicyPrincipals

                                                                                                                                                                                                                                                                                                                func (c *Client) ListPolicyPrincipals(ctx context.Context, params *ListPolicyPrincipalsInput, optFns ...func(*Options)) (*ListPolicyPrincipalsOutput, error)

                                                                                                                                                                                                                                                                                                                  Lists the principals associated with the specified policy. Note: This API is deprecated. Please use ListTargetsForPolicy instead.

                                                                                                                                                                                                                                                                                                                  Deprecated: This operation has been deprecated.

                                                                                                                                                                                                                                                                                                                  func (*Client) ListPolicyVersions

                                                                                                                                                                                                                                                                                                                  func (c *Client) ListPolicyVersions(ctx context.Context, params *ListPolicyVersionsInput, optFns ...func(*Options)) (*ListPolicyVersionsOutput, error)

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

                                                                                                                                                                                                                                                                                                                    func (*Client) ListPrincipalPolicies

                                                                                                                                                                                                                                                                                                                    func (c *Client) ListPrincipalPolicies(ctx context.Context, params *ListPrincipalPoliciesInput, optFns ...func(*Options)) (*ListPrincipalPoliciesOutput, error)

                                                                                                                                                                                                                                                                                                                      Lists the policies attached to the specified principal. If you use an Cognito identity, the ID must be in AmazonCognito Identity format (https://docs.aws.amazon.com/cognitoidentity/latest/APIReference/API_GetCredentialsForIdentity.html#API_GetCredentialsForIdentity_RequestSyntax). Note: This API is deprecated. Please use ListAttachedPolicies instead.

                                                                                                                                                                                                                                                                                                                      Deprecated: This operation has been deprecated.

                                                                                                                                                                                                                                                                                                                      func (*Client) ListPrincipalThings

                                                                                                                                                                                                                                                                                                                      func (c *Client) ListPrincipalThings(ctx context.Context, params *ListPrincipalThingsInput, optFns ...func(*Options)) (*ListPrincipalThingsOutput, error)

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

                                                                                                                                                                                                                                                                                                                        func (*Client) ListProvisioningTemplateVersions

                                                                                                                                                                                                                                                                                                                        func (c *Client) ListProvisioningTemplateVersions(ctx context.Context, params *ListProvisioningTemplateVersionsInput, optFns ...func(*Options)) (*ListProvisioningTemplateVersionsOutput, error)

                                                                                                                                                                                                                                                                                                                          A list of fleet provisioning template versions.

                                                                                                                                                                                                                                                                                                                          func (*Client) ListProvisioningTemplates

                                                                                                                                                                                                                                                                                                                          func (c *Client) ListProvisioningTemplates(ctx context.Context, params *ListProvisioningTemplatesInput, optFns ...func(*Options)) (*ListProvisioningTemplatesOutput, error)

                                                                                                                                                                                                                                                                                                                            Lists the fleet provisioning templates in your AWS account.

                                                                                                                                                                                                                                                                                                                            func (*Client) ListRoleAliases

                                                                                                                                                                                                                                                                                                                            func (c *Client) ListRoleAliases(ctx context.Context, params *ListRoleAliasesInput, optFns ...func(*Options)) (*ListRoleAliasesOutput, error)

                                                                                                                                                                                                                                                                                                                              Lists the role aliases registered in your account.

                                                                                                                                                                                                                                                                                                                              func (*Client) ListScheduledAudits

                                                                                                                                                                                                                                                                                                                              func (c *Client) ListScheduledAudits(ctx context.Context, params *ListScheduledAuditsInput, optFns ...func(*Options)) (*ListScheduledAuditsOutput, error)

                                                                                                                                                                                                                                                                                                                                Lists all of your scheduled audits.

                                                                                                                                                                                                                                                                                                                                func (*Client) ListSecurityProfiles

                                                                                                                                                                                                                                                                                                                                func (c *Client) ListSecurityProfiles(ctx context.Context, params *ListSecurityProfilesInput, optFns ...func(*Options)) (*ListSecurityProfilesOutput, error)

                                                                                                                                                                                                                                                                                                                                  Lists the Device Defender security profiles you have created. You can use filters to list only those security profiles associated with a thing group or only those associated with your account.

                                                                                                                                                                                                                                                                                                                                  func (*Client) ListSecurityProfilesForTarget

                                                                                                                                                                                                                                                                                                                                  func (c *Client) ListSecurityProfilesForTarget(ctx context.Context, params *ListSecurityProfilesForTargetInput, optFns ...func(*Options)) (*ListSecurityProfilesForTargetOutput, error)

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

                                                                                                                                                                                                                                                                                                                                    func (*Client) ListStreams

                                                                                                                                                                                                                                                                                                                                    func (c *Client) ListStreams(ctx context.Context, params *ListStreamsInput, optFns ...func(*Options)) (*ListStreamsOutput, error)

                                                                                                                                                                                                                                                                                                                                      Lists all of the streams in your AWS account.

                                                                                                                                                                                                                                                                                                                                      func (*Client) ListTagsForResource

                                                                                                                                                                                                                                                                                                                                      func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

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

                                                                                                                                                                                                                                                                                                                                        func (*Client) ListTargetsForPolicy

                                                                                                                                                                                                                                                                                                                                        func (c *Client) ListTargetsForPolicy(ctx context.Context, params *ListTargetsForPolicyInput, optFns ...func(*Options)) (*ListTargetsForPolicyOutput, error)

                                                                                                                                                                                                                                                                                                                                          List targets for the specified policy.

                                                                                                                                                                                                                                                                                                                                          func (*Client) ListTargetsForSecurityProfile

                                                                                                                                                                                                                                                                                                                                          func (c *Client) ListTargetsForSecurityProfile(ctx context.Context, params *ListTargetsForSecurityProfileInput, optFns ...func(*Options)) (*ListTargetsForSecurityProfileOutput, error)

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

                                                                                                                                                                                                                                                                                                                                            func (*Client) ListThingGroups

                                                                                                                                                                                                                                                                                                                                            func (c *Client) ListThingGroups(ctx context.Context, params *ListThingGroupsInput, optFns ...func(*Options)) (*ListThingGroupsOutput, error)

                                                                                                                                                                                                                                                                                                                                              List the thing groups in your account.

                                                                                                                                                                                                                                                                                                                                              func (*Client) ListThingGroupsForThing

                                                                                                                                                                                                                                                                                                                                              func (c *Client) ListThingGroupsForThing(ctx context.Context, params *ListThingGroupsForThingInput, optFns ...func(*Options)) (*ListThingGroupsForThingOutput, error)

                                                                                                                                                                                                                                                                                                                                                List the thing groups to which the specified thing belongs.

                                                                                                                                                                                                                                                                                                                                                func (*Client) ListThingPrincipals

                                                                                                                                                                                                                                                                                                                                                func (c *Client) ListThingPrincipals(ctx context.Context, params *ListThingPrincipalsInput, optFns ...func(*Options)) (*ListThingPrincipalsOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                  func (*Client) ListThingRegistrationTaskReports

                                                                                                                                                                                                                                                                                                                                                  func (c *Client) ListThingRegistrationTaskReports(ctx context.Context, params *ListThingRegistrationTaskReportsInput, optFns ...func(*Options)) (*ListThingRegistrationTaskReportsOutput, error)

                                                                                                                                                                                                                                                                                                                                                    Information about the thing registration tasks.

                                                                                                                                                                                                                                                                                                                                                    func (*Client) ListThingRegistrationTasks

                                                                                                                                                                                                                                                                                                                                                    func (c *Client) ListThingRegistrationTasks(ctx context.Context, params *ListThingRegistrationTasksInput, optFns ...func(*Options)) (*ListThingRegistrationTasksOutput, error)

                                                                                                                                                                                                                                                                                                                                                      List bulk thing provisioning tasks.

                                                                                                                                                                                                                                                                                                                                                      func (*Client) ListThingTypes

                                                                                                                                                                                                                                                                                                                                                      func (c *Client) ListThingTypes(ctx context.Context, params *ListThingTypesInput, optFns ...func(*Options)) (*ListThingTypesOutput, error)

                                                                                                                                                                                                                                                                                                                                                        Lists the existing thing types.

                                                                                                                                                                                                                                                                                                                                                        func (*Client) ListThings

                                                                                                                                                                                                                                                                                                                                                        func (c *Client) ListThings(ctx context.Context, params *ListThingsInput, optFns ...func(*Options)) (*ListThingsOutput, error)

                                                                                                                                                                                                                                                                                                                                                          Lists your things. Use the attributeName and attributeValue parameters to filter your things. For example, calling ListThings with attributeName=Color and attributeValue=Red retrieves all things in the registry that contain an attribute Color with the value Red. You will not be charged for calling this API if an Access denied error is returned. You will also not be charged if no attributes or pagination token was provided in request and no pagination token and no results were returned.

                                                                                                                                                                                                                                                                                                                                                          func (*Client) ListThingsInBillingGroup

                                                                                                                                                                                                                                                                                                                                                          func (c *Client) ListThingsInBillingGroup(ctx context.Context, params *ListThingsInBillingGroupInput, optFns ...func(*Options)) (*ListThingsInBillingGroupOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                            func (*Client) ListThingsInThingGroup

                                                                                                                                                                                                                                                                                                                                                            func (c *Client) ListThingsInThingGroup(ctx context.Context, params *ListThingsInThingGroupInput, optFns ...func(*Options)) (*ListThingsInThingGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                              Lists the things in the specified group.

                                                                                                                                                                                                                                                                                                                                                              func (*Client) ListTopicRuleDestinations

                                                                                                                                                                                                                                                                                                                                                              func (c *Client) ListTopicRuleDestinations(ctx context.Context, params *ListTopicRuleDestinationsInput, optFns ...func(*Options)) (*ListTopicRuleDestinationsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                Lists all the topic rule destinations in your AWS account.

                                                                                                                                                                                                                                                                                                                                                                func (*Client) ListTopicRules

                                                                                                                                                                                                                                                                                                                                                                func (c *Client) ListTopicRules(ctx context.Context, params *ListTopicRulesInput, optFns ...func(*Options)) (*ListTopicRulesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                  Lists the rules for the specific topic.

                                                                                                                                                                                                                                                                                                                                                                  func (*Client) ListV2LoggingLevels

                                                                                                                                                                                                                                                                                                                                                                  func (c *Client) ListV2LoggingLevels(ctx context.Context, params *ListV2LoggingLevelsInput, optFns ...func(*Options)) (*ListV2LoggingLevelsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                    Lists logging levels.

                                                                                                                                                                                                                                                                                                                                                                    func (*Client) ListViolationEvents

                                                                                                                                                                                                                                                                                                                                                                    func (c *Client) ListViolationEvents(ctx context.Context, params *ListViolationEventsInput, optFns ...func(*Options)) (*ListViolationEventsOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                      func (*Client) RegisterCACertificate

                                                                                                                                                                                                                                                                                                                                                                      func (c *Client) RegisterCACertificate(ctx context.Context, params *RegisterCACertificateInput, optFns ...func(*Options)) (*RegisterCACertificateOutput, error)

                                                                                                                                                                                                                                                                                                                                                                        Registers a CA certificate with AWS IoT. This CA certificate can then be used to sign device certificates, which can be then registered with AWS IoT. You can register up to 10 CA certificates per AWS account that have the same subject field. This enables you to have up to 10 certificate authorities sign your device certificates. If you have more than one CA certificate registered, make sure you pass the CA certificate when you register your device certificates with the RegisterCertificate API.

                                                                                                                                                                                                                                                                                                                                                                        func (*Client) RegisterCertificate

                                                                                                                                                                                                                                                                                                                                                                        func (c *Client) RegisterCertificate(ctx context.Context, params *RegisterCertificateInput, optFns ...func(*Options)) (*RegisterCertificateOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                          func (*Client) RegisterCertificateWithoutCA

                                                                                                                                                                                                                                                                                                                                                                          func (c *Client) RegisterCertificateWithoutCA(ctx context.Context, params *RegisterCertificateWithoutCAInput, optFns ...func(*Options)) (*RegisterCertificateWithoutCAOutput, error)

                                                                                                                                                                                                                                                                                                                                                                            Register a certificate that does not have a certificate authority (CA).

                                                                                                                                                                                                                                                                                                                                                                            func (*Client) RegisterThing

                                                                                                                                                                                                                                                                                                                                                                            func (c *Client) RegisterThing(ctx context.Context, params *RegisterThingInput, optFns ...func(*Options)) (*RegisterThingOutput, error)

                                                                                                                                                                                                                                                                                                                                                                              Provisions a thing in the device registry. RegisterThing calls other AWS IoT control plane APIs. These calls might exceed your account level AWS IoT Throttling Limits (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_iot) and cause throttle errors. Please contact AWS Customer Support (https://console.aws.amazon.com/support/home) to raise your throttling limits if necessary.

                                                                                                                                                                                                                                                                                                                                                                              func (*Client) RejectCertificateTransfer

                                                                                                                                                                                                                                                                                                                                                                              func (c *Client) RejectCertificateTransfer(ctx context.Context, params *RejectCertificateTransferInput, optFns ...func(*Options)) (*RejectCertificateTransferOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                Rejects a pending certificate transfer. After AWS IoT rejects a certificate transfer, the certificate status changes from PENDING_TRANSFER to INACTIVE. To check for pending certificate transfers, call ListCertificates to enumerate your certificates. This operation can only be called by the transfer destination. After it is called, the certificate will be returned to the source's account in the INACTIVE state.

                                                                                                                                                                                                                                                                                                                                                                                func (*Client) RemoveThingFromBillingGroup

                                                                                                                                                                                                                                                                                                                                                                                func (c *Client) RemoveThingFromBillingGroup(ctx context.Context, params *RemoveThingFromBillingGroupInput, optFns ...func(*Options)) (*RemoveThingFromBillingGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                  Removes the given thing from the billing group.

                                                                                                                                                                                                                                                                                                                                                                                  func (*Client) RemoveThingFromThingGroup

                                                                                                                                                                                                                                                                                                                                                                                  func (c *Client) RemoveThingFromThingGroup(ctx context.Context, params *RemoveThingFromThingGroupInput, optFns ...func(*Options)) (*RemoveThingFromThingGroupOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                    func (*Client) ReplaceTopicRule

                                                                                                                                                                                                                                                                                                                                                                                    func (c *Client) ReplaceTopicRule(ctx context.Context, params *ReplaceTopicRuleInput, optFns ...func(*Options)) (*ReplaceTopicRuleOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                      func (*Client) SearchIndex

                                                                                                                                                                                                                                                                                                                                                                                      func (c *Client) SearchIndex(ctx context.Context, params *SearchIndexInput, optFns ...func(*Options)) (*SearchIndexOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                        The query search index.

                                                                                                                                                                                                                                                                                                                                                                                        func (*Client) SetDefaultAuthorizer

                                                                                                                                                                                                                                                                                                                                                                                        func (c *Client) SetDefaultAuthorizer(ctx context.Context, params *SetDefaultAuthorizerInput, optFns ...func(*Options)) (*SetDefaultAuthorizerOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                          func (*Client) SetDefaultPolicyVersion

                                                                                                                                                                                                                                                                                                                                                                                          func (c *Client) SetDefaultPolicyVersion(ctx context.Context, params *SetDefaultPolicyVersionInput, optFns ...func(*Options)) (*SetDefaultPolicyVersionOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                            func (*Client) SetLoggingOptions

                                                                                                                                                                                                                                                                                                                                                                                            func (c *Client) SetLoggingOptions(ctx context.Context, params *SetLoggingOptionsInput, optFns ...func(*Options)) (*SetLoggingOptionsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                              Sets the logging options. NOTE: use of this command is not recommended. Use SetV2LoggingOptions instead.

                                                                                                                                                                                                                                                                                                                                                                                              func (*Client) SetV2LoggingLevel

                                                                                                                                                                                                                                                                                                                                                                                              func (c *Client) SetV2LoggingLevel(ctx context.Context, params *SetV2LoggingLevelInput, optFns ...func(*Options)) (*SetV2LoggingLevelOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                Sets the logging level.

                                                                                                                                                                                                                                                                                                                                                                                                func (*Client) SetV2LoggingOptions

                                                                                                                                                                                                                                                                                                                                                                                                func (c *Client) SetV2LoggingOptions(ctx context.Context, params *SetV2LoggingOptionsInput, optFns ...func(*Options)) (*SetV2LoggingOptionsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                  Sets the logging options for the V2 logging service.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*Client) StartAuditMitigationActionsTask

                                                                                                                                                                                                                                                                                                                                                                                                  func (c *Client) StartAuditMitigationActionsTask(ctx context.Context, params *StartAuditMitigationActionsTaskInput, optFns ...func(*Options)) (*StartAuditMitigationActionsTaskOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                    func (*Client) StartOnDemandAuditTask

                                                                                                                                                                                                                                                                                                                                                                                                    func (c *Client) StartOnDemandAuditTask(ctx context.Context, params *StartOnDemandAuditTaskInput, optFns ...func(*Options)) (*StartOnDemandAuditTaskOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                      Starts an on-demand Device Defender audit.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*Client) StartThingRegistrationTask

                                                                                                                                                                                                                                                                                                                                                                                                      func (c *Client) StartThingRegistrationTask(ctx context.Context, params *StartThingRegistrationTaskInput, optFns ...func(*Options)) (*StartThingRegistrationTaskOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                        Creates a bulk thing provisioning task.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*Client) StopThingRegistrationTask

                                                                                                                                                                                                                                                                                                                                                                                                        func (c *Client) StopThingRegistrationTask(ctx context.Context, params *StopThingRegistrationTaskInput, optFns ...func(*Options)) (*StopThingRegistrationTaskOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                          Cancels a bulk thing provisioning task.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*Client) TagResource

                                                                                                                                                                                                                                                                                                                                                                                                          func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                            func (*Client) TestAuthorization

                                                                                                                                                                                                                                                                                                                                                                                                            func (c *Client) TestAuthorization(ctx context.Context, params *TestAuthorizationInput, optFns ...func(*Options)) (*TestAuthorizationOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                              func (*Client) TestInvokeAuthorizer

                                                                                                                                                                                                                                                                                                                                                                                                              func (c *Client) TestInvokeAuthorizer(ctx context.Context, params *TestInvokeAuthorizerInput, optFns ...func(*Options)) (*TestInvokeAuthorizerOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                                func (*Client) TransferCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                func (c *Client) TransferCertificate(ctx context.Context, params *TransferCertificateInput, optFns ...func(*Options)) (*TransferCertificateOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                  Transfers the specified certificate to the specified AWS account. You can cancel the transfer until it is acknowledged by the recipient. No notification is sent to the transfer destination's account. It is up to the caller to notify the transfer target. The certificate being transferred must not be in the ACTIVE state. You can use the UpdateCertificate API to deactivate it. The certificate must not have any policies attached to it. You can use the DetachPrincipalPolicy API to detach them.

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Client) UntagResource

                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                    Removes the given tags (metadata) from the resource.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Client) UpdateAccountAuditConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *Client) UpdateAccountAuditConfiguration(ctx context.Context, params *UpdateAccountAuditConfigurationInput, optFns ...func(*Options)) (*UpdateAccountAuditConfigurationOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Client) UpdateAuditSuppression

                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *Client) UpdateAuditSuppression(ctx context.Context, params *UpdateAuditSuppressionInput, optFns ...func(*Options)) (*UpdateAuditSuppressionOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                        Updates a Device Defender audit suppression.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Client) UpdateAuthorizer

                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *Client) UpdateAuthorizer(ctx context.Context, params *UpdateAuthorizerInput, optFns ...func(*Options)) (*UpdateAuthorizerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                          Updates an authorizer.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Client) UpdateBillingGroup

                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *Client) UpdateBillingGroup(ctx context.Context, params *UpdateBillingGroupInput, optFns ...func(*Options)) (*UpdateBillingGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                            Updates information about the billing group.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Client) UpdateCACertificate

                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *Client) UpdateCACertificate(ctx context.Context, params *UpdateCACertificateInput, optFns ...func(*Options)) (*UpdateCACertificateOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                              Updates a registered CA certificate.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Client) UpdateCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *Client) UpdateCertificate(ctx context.Context, params *UpdateCertificateInput, optFns ...func(*Options)) (*UpdateCertificateOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                Updates the status of the specified certificate. This operation is idempotent. Certificates must be in the ACTIVE state to authenticate devices that use a certificate to connect to AWS IoT. Within a few minutes of updating a certificate from the ACTIVE state to any other state, AWS IoT disconnects all devices that used that certificate to connect. Devices cannot use a certificate that is not in the ACTIVE state to reconnect.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Client) UpdateDimension

                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *Client) UpdateDimension(ctx context.Context, params *UpdateDimensionInput, optFns ...func(*Options)) (*UpdateDimensionOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Client) UpdateDomainConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *Client) UpdateDomainConfiguration(ctx context.Context, params *UpdateDomainConfigurationInput, optFns ...func(*Options)) (*UpdateDomainConfigurationOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                    Updates values stored in the domain configuration. Domain configurations for default endpoints can't be updated. The domain configuration feature is in public preview and is subject to change.

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Client) UpdateDynamicThingGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *Client) UpdateDynamicThingGroup(ctx context.Context, params *UpdateDynamicThingGroupInput, optFns ...func(*Options)) (*UpdateDynamicThingGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      Updates a dynamic thing group.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Client) UpdateEventConfigurations

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *Client) UpdateEventConfigurations(ctx context.Context, params *UpdateEventConfigurationsInput, optFns ...func(*Options)) (*UpdateEventConfigurationsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Updates the event configurations.

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Client) UpdateIndexingConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *Client) UpdateIndexingConfiguration(ctx context.Context, params *UpdateIndexingConfigurationInput, optFns ...func(*Options)) (*UpdateIndexingConfigurationOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                          Updates the search configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Client) UpdateJob

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *Client) UpdateJob(ctx context.Context, params *UpdateJobInput, optFns ...func(*Options)) (*UpdateJobOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                            Updates supported fields of the specified job.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Client) UpdateMitigationAction

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *Client) UpdateMitigationAction(ctx context.Context, params *UpdateMitigationActionInput, optFns ...func(*Options)) (*UpdateMitigationActionOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                              Updates the definition for the specified mitigation action.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Client) UpdateProvisioningTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *Client) UpdateProvisioningTemplate(ctx context.Context, params *UpdateProvisioningTemplateInput, optFns ...func(*Options)) (*UpdateProvisioningTemplateOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                Updates a fleet provisioning template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Client) UpdateRoleAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *Client) UpdateRoleAlias(ctx context.Context, params *UpdateRoleAliasInput, optFns ...func(*Options)) (*UpdateRoleAliasOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Updates a role alias.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Client) UpdateScheduledAudit

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *Client) UpdateScheduledAudit(ctx context.Context, params *UpdateScheduledAuditInput, optFns ...func(*Options)) (*UpdateScheduledAuditOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Client) UpdateSecurityProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *Client) UpdateSecurityProfile(ctx context.Context, params *UpdateSecurityProfileInput, optFns ...func(*Options)) (*UpdateSecurityProfileOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Updates a Device Defender security profile.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Client) UpdateStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *Client) UpdateStream(ctx context.Context, params *UpdateStreamInput, optFns ...func(*Options)) (*UpdateStreamOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Client) UpdateThing

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *Client) UpdateThing(ctx context.Context, params *UpdateThingInput, optFns ...func(*Options)) (*UpdateThingOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Updates the data for a thing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Client) UpdateThingGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *Client) UpdateThingGroup(ctx context.Context, params *UpdateThingGroupInput, optFns ...func(*Options)) (*UpdateThingGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Update a thing group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Client) UpdateThingGroupsForThing

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *Client) UpdateThingGroupsForThing(ctx context.Context, params *UpdateThingGroupsForThingInput, optFns ...func(*Options)) (*UpdateThingGroupsForThingOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Updates the groups to which the thing belongs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Client) UpdateTopicRuleDestination

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *Client) UpdateTopicRuleDestination(ctx context.Context, params *UpdateTopicRuleDestinationInput, optFns ...func(*Options)) (*UpdateTopicRuleDestinationOutput, error)

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Client) ValidateSecurityProfileBehaviors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *Client) ValidateSecurityProfileBehaviors(ctx context.Context, params *ValidateSecurityProfileBehaviorsInput, optFns ...func(*Options)) (*ValidateSecurityProfileBehaviorsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Validates a Device Defender security profile behaviors specification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ConfirmTopicRuleDestinationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ConfirmTopicRuleDestinationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The token used to confirm ownership or access to the topic rule confirmation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// URL.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ConfirmationToken *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ConfirmTopicRuleDestinationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ConfirmTopicRuleDestinationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuditSuppressionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuditSuppressionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// An audit check name. Checks must be enabled for your account. (Use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// DescribeAccountAuditConfiguration to see the list of all checks, including those
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// that are enabled or use UpdateAccountAuditConfiguration to select which checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// are enabled.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CheckName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The epoch timestamp in seconds at which this suppression expires.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Information that identifies the noncompliant resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResourceIdentifier *types.ResourceIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The description of the audit suppression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The epoch timestamp in seconds at which this suppression expires.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ExpirationDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Indicates whether a suppression should exist indefinitely or not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SuppressIndefinitely *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuditSuppressionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuditSuppressionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuthorizerInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuthorizerInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN of the authorizer's Lambda function.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AuthorizerFunctionArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The authorizer name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AuthorizerName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies whether AWS IoT validates the token signature in an authorization
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SigningDisabled *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The status of the create authorizer request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Status types.AuthorizerStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata which can be used to manage the custom authorizer. For URI Request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// parameters use format: ...key1=value1&key2=value2... For the CLI command-line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// parameter use format: &&tags "key1=value1&key2=value2..." For the cli-input-json
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// file use format: "tags": "key1=value1&key2=value2..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the token key used to extract the token from the HTTP headers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TokenKeyName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The public keys used to verify the digital signature returned by your custom
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// authentication service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TokenSigningPublicKeys map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuthorizerOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateAuthorizerOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The authorizer ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AuthorizerArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The authorizer's name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AuthorizerName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateBillingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateBillingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name you wish to give to the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BillingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The properties of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BillingGroupProperties *types.BillingGroupProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata which can be used to manage the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateBillingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateBillingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BillingGroupArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BillingGroupId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name you gave to the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BillingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateCertificateFromCsrInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateCertificateFromCsrInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The certificate signing request (CSR).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CertificateSigningRequest *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies whether the certificate is active.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SetAsActive bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The input for the CreateCertificateFromCsr operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateCertificateFromCsrOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateCertificateFromCsrOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the certificate. You can use the ARN as a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// principal for policy operations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CertificateArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ID of the certificate. Certificate management operations only take a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// certificateId.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The certificate data, in PEM format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CertificatePem *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The output from the CreateCertificateFromCsr operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDimensionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDimensionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Each dimension must have a unique client request token. If you try to create a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// new dimension with the same token as a dimension that already exists, an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// exception occurs. If you omit this value, AWS SDKs will automatically generate a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// unique client request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ClientRequestToken *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A unique identifier for the dimension. Choose something that describes the type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// and value to make it easy to remember what it does.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Specifies the value or list of values for the dimension. For TOPIC_FILTER
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// dimensions, this is a pattern used to match the MQTT topic (for example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// "admin/#").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	StringValues []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Specifies the type of dimension. Supported types: TOPIC_FILTER.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Type types.DimensionType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata that can be used to manage the dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDimensionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDimensionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ARN (Amazon resource name) of the created dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A unique identifier for the dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDomainConfigurationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDomainConfigurationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the domain configuration. This value must be unique to a region.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DomainConfigurationName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// An object that specifies the authorization service for a domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AuthorizerConfig *types.AuthorizerConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DomainName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ARNs of the certificates that AWS IoT passes to the device during the TLS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// handshake. Currently you can specify only one certificate ARN. This value is not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// required for AWS-managed domains.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ServerCertificateArns []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The type of service delivered by the endpoint. AWS IoT Core currently supports
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// only the DATA service type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ServiceType types.ServiceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata which can be used to manage the domain configuration. For URI Request
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// parameters use format: ...key1=value1&key2=value2... For the CLI command-line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// parameter use format: &&tags "key1=value1&key2=value2..." For the cli-input-json
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// file use format: "tags": "key1=value1&key2=value2..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The certificate used to validate the server certificate and prove domain name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// ownership. This certificate must be signed by a public certificate authority.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This value is not required for AWS-managed domains.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ValidationCertificateArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDomainConfigurationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDomainConfigurationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ARN of the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DomainConfigurationArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DomainConfigurationName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDynamicThingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDynamicThingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group search query string. See Query Syntax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// (https://docs.aws.amazon.com/iot/latest/developerguide/query-syntax.html) for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// information about query string syntax.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	QueryString *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group name to create.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group index name. Currently one index is supported:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// "AWS_Things".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	IndexName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group query version. Currently one query version is supported:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// "2017-09-30". If not specified, the query version defaults to this value.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	QueryVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata which can be used to manage the dynamic thing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group properties.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingGroupProperties *types.ThingGroupProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDynamicThingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateDynamicThingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group index name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	IndexName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group search query string.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	QueryString *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group query version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	QueryVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingGroupArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingGroupId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The dynamic thing group name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateJobInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateJobInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A job identifier which must be unique for your AWS account. We recommend using a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// UUID. Alpha-numeric characters, "-" and "_" are valid for use here.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	JobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A list of things and thing groups to which the job should be sent.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Targets []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Allows you to create criteria to abort a job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AbortConfig *types.AbortConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// A short text description of the job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The job document. If the job document resides in an S3 bucket, you must use a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// placeholder link when specifying the document. The placeholder link is of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// following form: ${aws:iot:s3-presigned-url:https://s3.amazonaws.com/bucket/key}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// where bucket is your bucket name and key is the object in the bucket to which
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// you are linking.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Document *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// An S3 link to the job document.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DocumentSource *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Allows you to create a staged rollout of the job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	JobExecutionsRolloutConfig *types.JobExecutionsRolloutConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The namespace used to indicate that a job is a customer-managed job. When you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// specify a value for this parameter, AWS IoT Core sends jobs notifications to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// MQTT topics that contain the value in the following format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/ The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// namespaceId feature is in public preview.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	NamespaceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Configuration information for pre-signed S3 URLs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PresignedUrlConfig *types.PresignedUrlConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata which can be used to manage the job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Specifies whether the job will continue to run (CONTINUOUS), or will be complete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// after all those things specified as targets have completed the job (SNAPSHOT).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// If continuous, the job may also be run on a thing when a change is detected in a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// target. For example, a job will run on a thing when the thing is added to a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// target group, even after the job was completed by all things originally in the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TargetSelection types.TargetSelection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Specifies the amount of time each device has to finish its execution of the job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The timer is started when the job execution status is set to IN_PROGRESS. If the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// job execution status is not set to another terminal state before the time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// expires, it will be automatically set to TIMED_OUT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TimeoutConfig *types.TimeoutConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateJobOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateJobOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The job description.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The job ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	JobArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The unique identifier you assigned to this job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	JobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateKeysAndCertificateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateKeysAndCertificateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Specifies whether the certificate is active.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SetAsActive bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The input for the CreateKeysAndCertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateKeysAndCertificateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateKeysAndCertificateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ARN of the certificate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CertificateArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the certificate. AWS IoT issues a default subject name for the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// certificate (for example, AWS IoT Certificate).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The certificate data, in PEM format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CertificatePem *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The generated key pair.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	KeyPair *types.KeyPair
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The output of the CreateKeysAndCertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateMitigationActionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateMitigationActionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A friendly name for the action. Choose a friendly name that accurately describes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// the action (for example, EnableLoggingAction).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ActionName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Defines the type of action and the parameters for that action.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ActionParams *types.MitigationActionParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ARN of the IAM role that is used to apply the mitigation action.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata that can be used to manage the mitigation action.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateMitigationActionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateMitigationActionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ARN for the new mitigation action.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ActionArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A unique identifier for the new mitigation action.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ActionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateOTAUpdateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateOTAUpdateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The files to be streamed by the OTA update.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Files []types.OTAUpdateFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The ID of the OTA update to be created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	OtaUpdateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The IAM role that grants AWS IoT access to the Amazon S3, AWS IoT jobs and AWS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Code Signing resources to create an OTA update job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The devices targeted to receive OTA updates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Targets []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A list of additional OTA update parameters which are name-value pairs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AdditionalParameters map[string]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The criteria that determine when and how a job abort takes place.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AwsJobAbortConfig *types.AwsJobAbortConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Configuration for the rollout of OTA updates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AwsJobExecutionsRolloutConfig *types.AwsJobExecutionsRolloutConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Configuration information for pre-signed URLs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AwsJobPresignedUrlConfig *types.AwsJobPresignedUrlConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Specifies the amount of time each device has to finish its execution of the job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// A timer is started when the job execution status is set to IN_PROGRESS. If the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// job execution status is not set to another terminal state before the timer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// expires, it will be automatically set to TIMED_OUT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AwsJobTimeoutConfig *types.AwsJobTimeoutConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The description of the OTA update.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The protocol used to transfer the OTA update image. Valid values are [HTTP],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// [MQTT], [HTTP, MQTT]. When both HTTP and MQTT are specified, the target device
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// can choose the protocol.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Protocols []types.Protocol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata which can be used to manage updates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Specifies whether the update will continue to run (CONTINUOUS), or will be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// complete after all the things specified as targets have completed the update
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// (SNAPSHOT). If continuous, the update may also be run on a thing when a change
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// is detected in a target. For example, an update will run on a thing when the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// thing is added to a target group, even after the update was completed by all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// things originally in the group. Valid values: CONTINUOUS | SNAPSHOT.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	TargetSelection types.TargetSelection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateOTAUpdateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateOTAUpdateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The AWS IoT job ARN associated with the OTA update.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AwsIotJobArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The AWS IoT job ID associated with the OTA update.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AwsIotJobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The OTA update ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	OtaUpdateArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The OTA update ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	OtaUpdateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The OTA update status.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	OtaUpdateStatus types.OTAUpdateStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreatePolicyInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreatePolicyInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The JSON document that describes the policy. policyDocument must have a minimum
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// length of 1, with a maximum length of 2048, excluding whitespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	PolicyDocument *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The policy name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	PolicyName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata which can be used to manage the policy. For URI Request parameters use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// format: ...key1=value1&key2=value2... For the CLI command-line parameter use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// format: &&tags "key1=value1&key2=value2..." For the cli-input-json file use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// format: "tags": "key1=value1&key2=value2..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The input for the CreatePolicy operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreatePolicyOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreatePolicyOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The policy ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PolicyArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The JSON document that describes the policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PolicyDocument *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The policy name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PolicyName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The policy version ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PolicyVersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The output from the CreatePolicy operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreatePolicyVersionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreatePolicyVersionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The JSON document that describes the policy. Minimum length of 1. Maximum length
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// of 2048, excluding whitespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	PolicyDocument *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The policy name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	PolicyName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// 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).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SetAsDefault bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The input for the CreatePolicyVersion operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreatePolicyVersionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreatePolicyVersionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Specifies whether the policy version is the default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	IsDefaultVersion bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The policy ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PolicyArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The JSON document that describes the policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PolicyDocument *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The policy version ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PolicyVersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The output of the CreatePolicyVersion operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningClaimInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningClaimInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the provisioning template to use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningClaimOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningClaimOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the certificate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The provisioning claim certificate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CertificatePem *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The provisioning claim expiration time.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Expiration *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The provisioning claim key pair.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	KeyPair *types.KeyPair
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The role ARN for the role associated with the fleet provisioning template. This
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// IoT role grants permission to provision a device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ProvisioningRoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The JSON formatted contents of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateBody *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The description of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// True to enable the fleet provisioning template, otherwise false.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Enabled bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Creates a pre-provisioning hook template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PreProvisioningHook *types.ProvisioningHook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata which can be used to manage the fleet provisioning template. For URI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Request parameters use format: ...key1=value1&key2=value2... For the CLI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// command-line parameter use format: &&tags "key1=value1&key2=value2..." For the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// cli-input-json file use format: "tags": "key1=value1&key2=value2..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The default version of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DefaultVersionId *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN that identifies the provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateVersionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateVersionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The JSON formatted contents of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateBody *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Sets a fleet provision template version as the default version.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SetAsDefault bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateVersionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateProvisioningTemplateVersionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// True if the fleet provisioning template version is the default version,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// otherwise false.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	IsDefaultVersion bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN that identifies the provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The version of the fleet provisioning template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VersionId *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateRoleAliasInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateRoleAliasInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The role alias that points to a role ARN. This allows you to change the role
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// without having to update the device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RoleAlias *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The role ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// How long (in seconds) the credentials will be valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CredentialDurationSeconds *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata which can be used to manage the role alias. For URI Request parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// use format: ...key1=value1&key2=value2... For the CLI command-line parameter use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// format: &&tags "key1=value1&key2=value2..." For the cli-input-json file use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// format: "tags": "key1=value1&key2=value2..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateRoleAliasOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateRoleAliasOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The role alias.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RoleAlias *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The role alias ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RoleAliasArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateScheduledAuditInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateScheduledAuditInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// How often the scheduled audit takes place. Can be one of "DAILY", "WEEKLY",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// "BIWEEKLY" or "MONTHLY". The start time of each audit is determined by the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// system.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Frequency types.AuditFrequency
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name you want to give to the scheduled audit. (Max. 128 chars)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ScheduledAuditName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Which checks are performed during the scheduled audit. Checks must be enabled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// for your account. (Use DescribeAccountAuditConfiguration to see the list of all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// checks, including those that are enabled or use UpdateAccountAuditConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// to select which checks are enabled.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TargetCheckNames []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The day of the month on which the scheduled audit takes place. Can be "1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// through "31" or "LAST". This field is required if the "frequency" parameter is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// set to "MONTHLY". If days 29-31 are specified, and the month does not have that
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// many days, the audit takes place on the "LAST" day of the month.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DayOfMonth *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The day of the week on which the scheduled audit takes place. Can be one of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// "SUN", "MON", "TUE", "WED", "THU", "FRI", or "SAT". This field is required if
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// the "frequency" parameter is set to "WEEKLY" or "BIWEEKLY".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DayOfWeek types.DayOfWeek
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata that can be used to manage the scheduled audit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateScheduledAuditOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateScheduledAuditOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN of the scheduled audit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ScheduledAuditArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateSecurityProfileInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateSecurityProfileInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name you are giving to the security profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityProfileName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Please use CreateSecurityProfileRequest$additionalMetricsToRetainV2 instead. A
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// list of metrics whose data is retained (stored). By default, data is retained
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// for any metric used in the profile's behaviors, but it is also retained for any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// metric specified here.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Deprecated: Use additionalMetricsToRetainV2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AdditionalMetricsToRetain []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A list of metrics whose data is retained (stored). By default, data is retained
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// for any metric used in the profile's behaviors, but it is also retained for any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// metric specified here.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AdditionalMetricsToRetainV2 []types.MetricToRetain
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies the destinations to which alerts are sent. (Alerts are always sent to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// the console.) Alerts are generated when a device (thing) violates a behavior.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AlertTargets map[string]types.AlertTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies the behaviors that, when violated by a device (thing), cause an alert.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Behaviors []types.Behavior
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A description of the security profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityProfileDescription *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata that can be used to manage the security profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateSecurityProfileOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateSecurityProfileOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN of the security profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityProfileArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name you gave to the security profile.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SecurityProfileName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateStreamInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateStreamInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The files to stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Files []types.StreamFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// An IAM role that allows the IoT service principal assumes to access your S3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The stream ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StreamId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A description of the stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata which can be used to manage streams.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateStreamOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateStreamOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// A description of the stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The stream ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StreamArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The stream ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StreamId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The version of the stream.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	StreamVersion *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateThingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateThingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The thing group name to create.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the parent thing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ParentGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata which can be used to manage the thing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The thing group properties.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingGroupProperties *types.ThingGroupProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateThingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateThingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The thing group ARN.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingGroupArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The thing group ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingGroupId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The thing group name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateThingInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreateThingInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the thing to create. You can't change a thing's name after you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// create it. To change a thing's name, you must create a new thing, give it the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// new name, and then delete the old thing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The attribute payload, which consists of up to three name/value pairs in a JSON
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// document. For example: {\"attributes\":{\"string1\":\"string2\"}}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AttributePayload *types.AttributePayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the billing group the thing will be added to.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BillingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the thing type associated with the new thing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingTypeName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The input for the CreateThing operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateThingOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreateThingOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The ARN of the new thing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ThingArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The thing ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ThingId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the new thing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ThingName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The output of the CreateThing operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateThingTypeInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreateThingTypeInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the thing type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingTypeName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata which can be used to manage the thing type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []types.Tag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The ThingTypeProperties for the thing type to create. It contains information
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// about the new thing type including a description, and a list of searchable thing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// attribute names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ThingTypeProperties *types.ThingTypeProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The input for the CreateThingType operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateThingTypeOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateThingTypeOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the thing type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ThingTypeArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The thing type ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ThingTypeId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the thing type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ThingTypeName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The output of the CreateThingType operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTopicRuleDestinationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTopicRuleDestinationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The topic rule destination configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	DestinationConfiguration *types.TopicRuleDestinationConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTopicRuleDestinationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTopicRuleDestinationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The topic rule destination.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	TopicRuleDestination *types.TopicRuleDestination
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTopicRuleInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreateTopicRuleInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the rule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RuleName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The rule payload.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	TopicRulePayload *types.TopicRulePayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata which can be used to manage the topic rule. For URI Request parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// use format: ...key1=value1&key2=value2... For the CLI command-line parameter use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// format: --tags "key1=value1&key2=value2..." For the cli-input-json file use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// format: "tags": "key1=value1&key2=value2..."
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Tags *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The input for the CreateTopicRule operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateTopicRuleOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreateTopicRuleOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAccountAuditConfigurationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAccountAuditConfigurationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// If true, all scheduled audits are deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	DeleteScheduledAudits bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAccountAuditConfigurationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAccountAuditConfigurationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuditSuppressionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuditSuppressionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// An audit check name. Checks must be enabled for your account. (Use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// DescribeAccountAuditConfiguration to see the list of all checks, including those
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// that are enabled or use UpdateAccountAuditConfiguration to select which checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// are enabled.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CheckName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Information that identifies the noncompliant resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResourceIdentifier *types.ResourceIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuditSuppressionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuditSuppressionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuthorizerInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuthorizerInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The name of the authorizer to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	AuthorizerName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuthorizerOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteAuthorizerOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteBillingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteBillingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The name of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	BillingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The expected version of the billing group. If the version of the billing group
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// does not match the expected version specified in the request, the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// DeleteBillingGroup request is rejected with a VersionConflictException.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ExpectedVersion *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteBillingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteBillingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteCACertificateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteCACertificateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The ID of the certificate to delete. (The last part of the certificate ARN
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains the certificate ID.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Input for the DeleteCACertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DeleteCACertificateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DeleteCACertificateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The output for the DeleteCACertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DeleteCertificateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DeleteCertificateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ID of the certificate. (The last part of the certificate ARN contains the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// certificate ID.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Forces the deletion of a certificate if it is inactive and is not attached to an
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// IoT thing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ForceDelete bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The input for the DeleteCertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteCertificateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteCertificateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDimensionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDimensionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The unique identifier for the dimension that you want to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDimensionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDimensionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDomainConfigurationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDomainConfigurationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the domain configuration to be deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DomainConfigurationName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDomainConfigurationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDomainConfigurationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDynamicThingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDynamicThingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the dynamic thing group to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The expected version of the dynamic thing group to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ExpectedVersion *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDynamicThingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteDynamicThingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobExecutionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobExecutionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the job execution to be deleted. The executionNumber refers to the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// execution of a particular job on a particular device. Note that once a job
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// execution is deleted, the executionNumber may be reused by IoT, so be sure you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// get and use the correct value here.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ExecutionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the job whose execution on a particular device will be deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the thing whose job execution will be deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ThingName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// (Optional) When true, you can delete a job execution which is "IN_PROGRESS".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Otherwise, you can only delete a job execution which is in a terminal state
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// ("SUCCEEDED", "FAILED", "REJECTED", "REMOVED" or "CANCELED") or an exception
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// will occur. The default is false. Deleting a job execution which is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// "IN_PROGRESS", will cause the device to be unable to access job information or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// update the job execution status. Use caution and ensure that the device is able
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// to recover to a valid state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Force bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The namespace used to indicate that a job is a customer-managed job. When you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// specify a value for this parameter, AWS IoT Core sends jobs notifications to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// MQTT topics that contain the value in the following format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/ The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// namespaceId feature is in public preview.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NamespaceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobExecutionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobExecutionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the job to be deleted. After a job deletion is completed, you may
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// reuse this jobId when you create a new job. However, this is not recommended,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// and you must ensure that your devices are not using the jobId to refer to the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// deleted job.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// (Optional) When true, you can delete a job which is "IN_PROGRESS". Otherwise,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// you can only delete a job which is in a terminal state ("COMPLETED" or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// "CANCELED") or an exception will occur. The default is false. Deleting a job
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// which is "IN_PROGRESS", will cause a device which is executing the job to be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// unable to access job information or update the job execution status. Use caution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// and ensure that each device executing a job which is deleted is able to recover
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// to a valid state.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Force bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The namespace used to indicate that a job is a customer-managed job. When you
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// specify a value for this parameter, AWS IoT Core sends jobs notifications to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// MQTT topics that contain the value in the following format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// $aws/things/THING_NAME/jobs/JOB_ID/notify-namespace-NAMESPACE_ID/ The
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// namespaceId feature is in public preview.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	NamespaceId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteJobOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteMitigationActionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteMitigationActionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the mitigation action that you want to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ActionName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteMitigationActionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteMitigationActionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteOTAUpdateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteOTAUpdateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ID of the OTA update to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	OtaUpdateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies if the stream associated with an OTA update should be deleted when the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// OTA update is deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DeleteStream bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Specifies if the AWS Job associated with the OTA update should be deleted when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// the OTA update is deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ForceDeleteAWSJob bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteOTAUpdateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteOTAUpdateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeletePolicyInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeletePolicyInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the policy to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PolicyName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The input for the DeletePolicy operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeletePolicyOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeletePolicyOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeletePolicyVersionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeletePolicyVersionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the policy.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PolicyName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The policy version ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PolicyVersionId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The input for the DeletePolicyVersion operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeletePolicyVersionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeletePolicyVersionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the fleet provision template to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateVersionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateVersionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The name of the fleet provisioning template version to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TemplateName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The fleet provisioning template version ID to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	VersionId *int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateVersionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteProvisioningTemplateVersionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteRegistrationCodeInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeleteRegistrationCodeInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The input for the DeleteRegistrationCode operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DeleteRegistrationCodeOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DeleteRegistrationCodeOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The output for the DeleteRegistrationCode operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteRoleAliasInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteRoleAliasInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The role alias to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RoleAlias *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteRoleAliasOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteRoleAliasOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteScheduledAuditInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteScheduledAuditInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the scheduled audit you want to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ScheduledAuditName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteScheduledAuditOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteScheduledAuditOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteSecurityProfileInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteSecurityProfileInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the security profile to be deleted.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SecurityProfileName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The expected version of the security profile. A new version is generated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// whenever the security profile is updated. If you specify a value that is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// different from the actual version, a VersionConflictException is thrown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ExpectedVersion *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteSecurityProfileOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteSecurityProfileOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteStreamInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteStreamInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The stream ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	StreamId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteStreamOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteStreamOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteThingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteThingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the thing group to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ThingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The expected version of the thing group to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ExpectedVersion *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteThingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteThingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteThingInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DeleteThingInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The name of the thing to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ThingName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The expected version of the thing record in the registry. If the version of the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// record in the registry does not match the expected version specified in the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// request, the DeleteThing request is rejected with a VersionConflictException.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ExpectedVersion *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The input for the DeleteThing operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteThingOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DeleteThingOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The output of the DeleteThing operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DeleteThingTypeInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DeleteThingTypeInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The name of the thing type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ThingTypeName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The input for the DeleteThingType operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DeleteThingTypeOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DeleteThingTypeOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The output for the DeleteThingType operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteTopicRuleDestinationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteTopicRuleDestinationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The ARN of the topic rule destination to delete.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteTopicRuleDestinationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteTopicRuleDestinationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteTopicRuleInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DeleteTopicRuleInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The name of the rule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RuleName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The input for the DeleteTopicRule operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteTopicRuleOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteTopicRuleOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteV2LoggingLevelInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteV2LoggingLevelInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the resource for which you are configuring logging.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TargetName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The type of resource for which you are configuring logging. Must be THING_Group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TargetType types.LogTargetType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteV2LoggingLevelOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeleteV2LoggingLevelOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeprecateThingTypeInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DeprecateThingTypeInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the thing type to deprecate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ThingTypeName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Whether to undeprecate a deprecated thing type. If true, the thing type will not
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// be deprecated anymore and you can associate it with things.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UndoDeprecate bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The input for the DeprecateThingType operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeprecateThingTypeOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DeprecateThingTypeOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The output for the DeprecateThingType operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAccountAuditConfigurationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAccountAuditConfigurationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAccountAuditConfigurationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAccountAuditConfigurationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Which audit checks are enabled and disabled for this account.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AuditCheckConfigurations map[string]types.AuditCheckConfiguration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information about the targets to which audit notifications are sent for this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// account.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AuditNotificationTargetConfigurations map[string]types.AuditNotificationTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ARN of the role that grants permission to AWS IoT to access information
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// about your devices, policies, certificates, and other items as required when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// performing an audit. On the first call to UpdateAccountAuditConfiguration, this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// parameter is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	RoleArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditFindingInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditFindingInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// A unique identifier for a single audit finding. You can use this identifier to
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// apply mitigation actions to the finding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FindingId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditFindingOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditFindingOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The findings (results) of the audit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Finding *types.AuditFinding
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditMitigationActionsTaskInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditMitigationActionsTaskInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The unique identifier for the audit mitigation task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditMitigationActionsTaskOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditMitigationActionsTaskOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Specifies the mitigation actions and their parameters that are applied as part
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// of this task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ActionsDefinition []types.MitigationAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Specifies the mitigation actions that should be applied to specific audit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// checks.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AuditCheckToActionsMapping map[string][]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The date and time when the task was completed or canceled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	EndTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The date and time when the task was started.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	StartTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Identifies the findings to which the mitigation actions are applied. This can be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// by audit checks, by audit task, or a set of findings.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Target *types.AuditMitigationActionsTaskTarget
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Aggregate counts of the results when the mitigation tasks were applied to the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// findings for this audit mitigation actions task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskStatistics map[string]types.TaskStatisticsForAuditCheck
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The current status of the task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskStatus types.AuditMitigationActionsTaskStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditSuppressionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditSuppressionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// An audit check name. Checks must be enabled for your account. (Use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// DescribeAccountAuditConfiguration to see the list of all checks, including those
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// that are enabled or use UpdateAccountAuditConfiguration to select which checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// are enabled.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CheckName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information that identifies the noncompliant resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResourceIdentifier *types.ResourceIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditSuppressionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditSuppressionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// An audit check name. Checks must be enabled for your account. (Use
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// DescribeAccountAuditConfiguration to see the list of all checks, including those
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// that are enabled or use UpdateAccountAuditConfiguration to select which checks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// are enabled.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CheckName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The description of the audit suppression.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The epoch timestamp in seconds at which this suppression expires.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ExpirationDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information that identifies the noncompliant resource.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResourceIdentifier *types.ResourceIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Indicates whether a suppression should exist indefinitely or not.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SuppressIndefinitely *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditTaskInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditTaskInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the audit whose information you want to get.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditTaskOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuditTaskOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Detailed information about each check performed during this audit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AuditDetails map[string]types.AuditCheckDetails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the scheduled audit (only if the audit was a scheduled audit).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ScheduledAuditName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The time the audit started.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskStartTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Statistical information about the audit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskStatistics *types.TaskStatistics
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The status of the audit: one of "IN_PROGRESS", "COMPLETED", "FAILED", or
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// "CANCELED".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskStatus types.AuditTaskStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The type of audit: "ON_DEMAND_AUDIT_TASK" or "SCHEDULED_AUDIT_TASK".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaskType types.AuditTaskType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuthorizerInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuthorizerInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the authorizer to describe.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AuthorizerName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuthorizerOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeAuthorizerOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The authorizer description.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AuthorizerDescription *types.AuthorizerDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeBillingGroupInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeBillingGroupInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BillingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeBillingGroupOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeBillingGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ARN of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BillingGroupArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The ID of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BillingGroupId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Additional information about the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BillingGroupMetadata *types.BillingGroupMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The name of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BillingGroupName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The properties of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BillingGroupProperties *types.BillingGroupProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The version of the billing group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Version int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeCACertificateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeCACertificateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The CA certificate identifier.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The input for the DescribeCACertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DescribeCACertificateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DescribeCACertificateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// The CA certificate description.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CertificateDescription *types.CACertificateDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Information about the registration configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RegistrationConfig *types.RegistrationConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The output from the DescribeCACertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeCertificateInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeCertificateInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The ID of the certificate. (The last part of the certificate ARN contains the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// certificate ID.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CertificateId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The input for the DescribeCertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeCertificateOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeCertificateOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The description of the certificate.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CertificateDescription *types.CertificateDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The output of the DescribeCertificate operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDefaultAuthorizerInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDefaultAuthorizerInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDefaultAuthorizerOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDefaultAuthorizerOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The default authorizer's description.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AuthorizerDescription *types.AuthorizerDescription
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDimensionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDimensionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The unique identifier for the dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDimensionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDimensionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ARN (Amazon resource name) for the dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Arn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The date the dimension was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreationDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The date the dimension was last modified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The unique identifier for the dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The value or list of values used to scope the dimension. For example, for topic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// filters, this is the pattern used to match the MQTT topic name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	StringValues []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The type of the dimension.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Type types.DimensionType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDomainConfigurationInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDomainConfigurationInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DomainConfigurationName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDomainConfigurationOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeDomainConfigurationOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// An object that specifies the authorization service for a domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AuthorizerConfig *types.AuthorizerConfig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The ARN of the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DomainConfigurationArn *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DomainConfigurationName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A Boolean value that specifies the current state of the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DomainConfigurationStatus types.DomainConfigurationStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The name of the domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DomainName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The type of the domain.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DomainType types.DomainType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The date and time the domain configuration's status was last changed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	LastStatusChangeDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// A list containing summary information about the server certificate included in
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the domain configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ServerCertificates []types.ServerCertificateSummary
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The type of service delivered by the endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ServiceType types.ServiceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeEndpointInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeEndpointInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The endpoint type. Valid endpoint types include:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// * iot:Data - Returns a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// VeriSign signed data endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// * iot:Data-ATS - Returns an ATS signed data
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// * iot:CredentialProvider - Returns an AWS IoT credentials provider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// API endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// * iot:Jobs - Returns an AWS IoT device management Jobs API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// endpoint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// We strongly recommend that customers use the newer iot:Data-ATS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// endpoint type to avoid issues related to the widespread distrust of Symantec
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// certificate authorities.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	EndpointType *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The input for the DescribeEndpoint operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DescribeEndpointOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DescribeEndpointOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The endpoint. The format of the endpoint is as follows:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// identifier.iot.region.amazonaws.com.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	EndpointAddress *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The output from the DescribeEndpoint operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeEventConfigurationsInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeEventConfigurationsInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeEventConfigurationsOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeEventConfigurationsOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The creation date of the event configuration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CreationDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The event configurations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	EventConfigurations map[string]types.Configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The date the event configurations were last modified.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	LastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeIndexInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeIndexInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The index name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IndexName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeIndexOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeIndexOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The index name.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IndexName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The index status.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IndexStatus types.IndexStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Contains a value that specifies the type of indexing performed. Valid values
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// are:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// * REGISTRY – Your thing index contains only registry data.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// REGISTRY_AND_SHADOW - Your thing index contains registry data and shadow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// data.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// * REGISTRY_AND_CONNECTIVITY_STATUS - Your thing index contains registry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// data and thing connectivity status data.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// REGISTRY_AND_SHADOW_AND_CONNECTIVITY_STATUS - Your thing index contains registry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// data, shadow data, and thing connectivity status data.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Schema *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeJobExecutionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeJobExecutionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The unique identifier you assigned to this job when it was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	JobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the thing on which the job execution is running.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ThingName *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// A string (consisting of the digits "0" through "9" which is used to specify a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// particular job execution on a particular device.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ExecutionNumber *int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeJobExecutionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeJobExecutionOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the job execution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Execution *types.JobExecution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeJobInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeJobInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The unique identifier you assigned to this job when it was created.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	JobId *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }