<reponame>temporalio/temporal-aws-sdk-go
// Generated by github.com/temporalio/temporal-aws-sdk-generator
// from github.com/aws/aws-sdk-go version 1.35.7
// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.

package iotstub

import (
	"github.com/aws/aws-sdk-go/service/iot"
	"go.temporal.io/sdk/workflow"

	"go.temporal.io/aws-sdk/clients"
)

// ensure that imports are valid even if not used by the generated code
var _ clients.VoidFuture

type stub struct{}

type AcceptCertificateTransferFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AcceptCertificateTransferFuture) Get(ctx workflow.Context) (*iot.AcceptCertificateTransferOutput, error) {
	var output iot.AcceptCertificateTransferOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AddThingToBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AddThingToBillingGroupFuture) Get(ctx workflow.Context) (*iot.AddThingToBillingGroupOutput, error) {
	var output iot.AddThingToBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AddThingToThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AddThingToThingGroupFuture) Get(ctx workflow.Context) (*iot.AddThingToThingGroupOutput, error) {
	var output iot.AddThingToThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AssociateTargetsWithJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AssociateTargetsWithJobFuture) Get(ctx workflow.Context) (*iot.AssociateTargetsWithJobOutput, error) {
	var output iot.AssociateTargetsWithJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AttachPolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AttachPolicyFuture) Get(ctx workflow.Context) (*iot.AttachPolicyOutput, error) {
	var output iot.AttachPolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AttachPrincipalPolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AttachPrincipalPolicyFuture) Get(ctx workflow.Context) (*iot.AttachPrincipalPolicyOutput, error) {
	var output iot.AttachPrincipalPolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AttachSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AttachSecurityProfileFuture) Get(ctx workflow.Context) (*iot.AttachSecurityProfileOutput, error) {
	var output iot.AttachSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type AttachThingPrincipalFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *AttachThingPrincipalFuture) Get(ctx workflow.Context) (*iot.AttachThingPrincipalOutput, error) {
	var output iot.AttachThingPrincipalOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CancelAuditMitigationActionsTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CancelAuditMitigationActionsTaskFuture) Get(ctx workflow.Context) (*iot.CancelAuditMitigationActionsTaskOutput, error) {
	var output iot.CancelAuditMitigationActionsTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CancelAuditTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CancelAuditTaskFuture) Get(ctx workflow.Context) (*iot.CancelAuditTaskOutput, error) {
	var output iot.CancelAuditTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CancelCertificateTransferFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CancelCertificateTransferFuture) Get(ctx workflow.Context) (*iot.CancelCertificateTransferOutput, error) {
	var output iot.CancelCertificateTransferOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CancelJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CancelJobFuture) Get(ctx workflow.Context) (*iot.CancelJobOutput, error) {
	var output iot.CancelJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CancelJobExecutionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CancelJobExecutionFuture) Get(ctx workflow.Context) (*iot.CancelJobExecutionOutput, error) {
	var output iot.CancelJobExecutionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ClearDefaultAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ClearDefaultAuthorizerFuture) Get(ctx workflow.Context) (*iot.ClearDefaultAuthorizerOutput, error) {
	var output iot.ClearDefaultAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ConfirmTopicRuleDestinationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ConfirmTopicRuleDestinationFuture) Get(ctx workflow.Context) (*iot.ConfirmTopicRuleDestinationOutput, error) {
	var output iot.ConfirmTopicRuleDestinationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateAuditSuppressionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateAuditSuppressionFuture) Get(ctx workflow.Context) (*iot.CreateAuditSuppressionOutput, error) {
	var output iot.CreateAuditSuppressionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateAuthorizerFuture) Get(ctx workflow.Context) (*iot.CreateAuthorizerOutput, error) {
	var output iot.CreateAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateBillingGroupFuture) Get(ctx workflow.Context) (*iot.CreateBillingGroupOutput, error) {
	var output iot.CreateBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateCertificateFromCsrFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateCertificateFromCsrFuture) Get(ctx workflow.Context) (*iot.CreateCertificateFromCsrOutput, error) {
	var output iot.CreateCertificateFromCsrOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDimensionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDimensionFuture) Get(ctx workflow.Context) (*iot.CreateDimensionOutput, error) {
	var output iot.CreateDimensionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDomainConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDomainConfigurationFuture) Get(ctx workflow.Context) (*iot.CreateDomainConfigurationOutput, error) {
	var output iot.CreateDomainConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateDynamicThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateDynamicThingGroupFuture) Get(ctx workflow.Context) (*iot.CreateDynamicThingGroupOutput, error) {
	var output iot.CreateDynamicThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateJobFuture) Get(ctx workflow.Context) (*iot.CreateJobOutput, error) {
	var output iot.CreateJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateKeysAndCertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateKeysAndCertificateFuture) Get(ctx workflow.Context) (*iot.CreateKeysAndCertificateOutput, error) {
	var output iot.CreateKeysAndCertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateMitigationActionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateMitigationActionFuture) Get(ctx workflow.Context) (*iot.CreateMitigationActionOutput, error) {
	var output iot.CreateMitigationActionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateOTAUpdateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateOTAUpdateFuture) Get(ctx workflow.Context) (*iot.CreateOTAUpdateOutput, error) {
	var output iot.CreateOTAUpdateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreatePolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreatePolicyFuture) Get(ctx workflow.Context) (*iot.CreatePolicyOutput, error) {
	var output iot.CreatePolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreatePolicyVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreatePolicyVersionFuture) Get(ctx workflow.Context) (*iot.CreatePolicyVersionOutput, error) {
	var output iot.CreatePolicyVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateProvisioningClaimFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateProvisioningClaimFuture) Get(ctx workflow.Context) (*iot.CreateProvisioningClaimOutput, error) {
	var output iot.CreateProvisioningClaimOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateProvisioningTemplateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateProvisioningTemplateFuture) Get(ctx workflow.Context) (*iot.CreateProvisioningTemplateOutput, error) {
	var output iot.CreateProvisioningTemplateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateProvisioningTemplateVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateProvisioningTemplateVersionFuture) Get(ctx workflow.Context) (*iot.CreateProvisioningTemplateVersionOutput, error) {
	var output iot.CreateProvisioningTemplateVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateRoleAliasFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateRoleAliasFuture) Get(ctx workflow.Context) (*iot.CreateRoleAliasOutput, error) {
	var output iot.CreateRoleAliasOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateScheduledAuditFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateScheduledAuditFuture) Get(ctx workflow.Context) (*iot.CreateScheduledAuditOutput, error) {
	var output iot.CreateScheduledAuditOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateSecurityProfileFuture) Get(ctx workflow.Context) (*iot.CreateSecurityProfileOutput, error) {
	var output iot.CreateSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateStreamFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateStreamFuture) Get(ctx workflow.Context) (*iot.CreateStreamOutput, error) {
	var output iot.CreateStreamOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateThingFuture) Get(ctx workflow.Context) (*iot.CreateThingOutput, error) {
	var output iot.CreateThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateThingGroupFuture) Get(ctx workflow.Context) (*iot.CreateThingGroupOutput, error) {
	var output iot.CreateThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateThingTypeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateThingTypeFuture) Get(ctx workflow.Context) (*iot.CreateThingTypeOutput, error) {
	var output iot.CreateThingTypeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateTopicRuleFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateTopicRuleFuture) Get(ctx workflow.Context) (*iot.CreateTopicRuleOutput, error) {
	var output iot.CreateTopicRuleOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type CreateTopicRuleDestinationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *CreateTopicRuleDestinationFuture) Get(ctx workflow.Context) (*iot.CreateTopicRuleDestinationOutput, error) {
	var output iot.CreateTopicRuleDestinationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteAccountAuditConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteAccountAuditConfigurationFuture) Get(ctx workflow.Context) (*iot.DeleteAccountAuditConfigurationOutput, error) {
	var output iot.DeleteAccountAuditConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteAuditSuppressionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteAuditSuppressionFuture) Get(ctx workflow.Context) (*iot.DeleteAuditSuppressionOutput, error) {
	var output iot.DeleteAuditSuppressionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteAuthorizerFuture) Get(ctx workflow.Context) (*iot.DeleteAuthorizerOutput, error) {
	var output iot.DeleteAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteBillingGroupFuture) Get(ctx workflow.Context) (*iot.DeleteBillingGroupOutput, error) {
	var output iot.DeleteBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteCACertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteCACertificateFuture) Get(ctx workflow.Context) (*iot.DeleteCACertificateOutput, error) {
	var output iot.DeleteCACertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteCertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteCertificateFuture) Get(ctx workflow.Context) (*iot.DeleteCertificateOutput, error) {
	var output iot.DeleteCertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDimensionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDimensionFuture) Get(ctx workflow.Context) (*iot.DeleteDimensionOutput, error) {
	var output iot.DeleteDimensionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDomainConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDomainConfigurationFuture) Get(ctx workflow.Context) (*iot.DeleteDomainConfigurationOutput, error) {
	var output iot.DeleteDomainConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteDynamicThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteDynamicThingGroupFuture) Get(ctx workflow.Context) (*iot.DeleteDynamicThingGroupOutput, error) {
	var output iot.DeleteDynamicThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteJobFuture) Get(ctx workflow.Context) (*iot.DeleteJobOutput, error) {
	var output iot.DeleteJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteJobExecutionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteJobExecutionFuture) Get(ctx workflow.Context) (*iot.DeleteJobExecutionOutput, error) {
	var output iot.DeleteJobExecutionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteMitigationActionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteMitigationActionFuture) Get(ctx workflow.Context) (*iot.DeleteMitigationActionOutput, error) {
	var output iot.DeleteMitigationActionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteOTAUpdateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteOTAUpdateFuture) Get(ctx workflow.Context) (*iot.DeleteOTAUpdateOutput, error) {
	var output iot.DeleteOTAUpdateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeletePolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeletePolicyFuture) Get(ctx workflow.Context) (*iot.DeletePolicyOutput, error) {
	var output iot.DeletePolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeletePolicyVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeletePolicyVersionFuture) Get(ctx workflow.Context) (*iot.DeletePolicyVersionOutput, error) {
	var output iot.DeletePolicyVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteProvisioningTemplateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteProvisioningTemplateFuture) Get(ctx workflow.Context) (*iot.DeleteProvisioningTemplateOutput, error) {
	var output iot.DeleteProvisioningTemplateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteProvisioningTemplateVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteProvisioningTemplateVersionFuture) Get(ctx workflow.Context) (*iot.DeleteProvisioningTemplateVersionOutput, error) {
	var output iot.DeleteProvisioningTemplateVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteRegistrationCodeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteRegistrationCodeFuture) Get(ctx workflow.Context) (*iot.DeleteRegistrationCodeOutput, error) {
	var output iot.DeleteRegistrationCodeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteRoleAliasFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteRoleAliasFuture) Get(ctx workflow.Context) (*iot.DeleteRoleAliasOutput, error) {
	var output iot.DeleteRoleAliasOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteScheduledAuditFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteScheduledAuditFuture) Get(ctx workflow.Context) (*iot.DeleteScheduledAuditOutput, error) {
	var output iot.DeleteScheduledAuditOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteSecurityProfileFuture) Get(ctx workflow.Context) (*iot.DeleteSecurityProfileOutput, error) {
	var output iot.DeleteSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteStreamFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteStreamFuture) Get(ctx workflow.Context) (*iot.DeleteStreamOutput, error) {
	var output iot.DeleteStreamOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteThingFuture) Get(ctx workflow.Context) (*iot.DeleteThingOutput, error) {
	var output iot.DeleteThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteThingGroupFuture) Get(ctx workflow.Context) (*iot.DeleteThingGroupOutput, error) {
	var output iot.DeleteThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteThingTypeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteThingTypeFuture) Get(ctx workflow.Context) (*iot.DeleteThingTypeOutput, error) {
	var output iot.DeleteThingTypeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteTopicRuleFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteTopicRuleFuture) Get(ctx workflow.Context) (*iot.DeleteTopicRuleOutput, error) {
	var output iot.DeleteTopicRuleOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteTopicRuleDestinationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteTopicRuleDestinationFuture) Get(ctx workflow.Context) (*iot.DeleteTopicRuleDestinationOutput, error) {
	var output iot.DeleteTopicRuleDestinationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeleteV2LoggingLevelFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeleteV2LoggingLevelFuture) Get(ctx workflow.Context) (*iot.DeleteV2LoggingLevelOutput, error) {
	var output iot.DeleteV2LoggingLevelOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DeprecateThingTypeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DeprecateThingTypeFuture) Get(ctx workflow.Context) (*iot.DeprecateThingTypeOutput, error) {
	var output iot.DeprecateThingTypeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAccountAuditConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAccountAuditConfigurationFuture) Get(ctx workflow.Context) (*iot.DescribeAccountAuditConfigurationOutput, error) {
	var output iot.DescribeAccountAuditConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAuditFindingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAuditFindingFuture) Get(ctx workflow.Context) (*iot.DescribeAuditFindingOutput, error) {
	var output iot.DescribeAuditFindingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAuditMitigationActionsTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAuditMitigationActionsTaskFuture) Get(ctx workflow.Context) (*iot.DescribeAuditMitigationActionsTaskOutput, error) {
	var output iot.DescribeAuditMitigationActionsTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAuditSuppressionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAuditSuppressionFuture) Get(ctx workflow.Context) (*iot.DescribeAuditSuppressionOutput, error) {
	var output iot.DescribeAuditSuppressionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAuditTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAuditTaskFuture) Get(ctx workflow.Context) (*iot.DescribeAuditTaskOutput, error) {
	var output iot.DescribeAuditTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeAuthorizerFuture) Get(ctx workflow.Context) (*iot.DescribeAuthorizerOutput, error) {
	var output iot.DescribeAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeBillingGroupFuture) Get(ctx workflow.Context) (*iot.DescribeBillingGroupOutput, error) {
	var output iot.DescribeBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeCACertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeCACertificateFuture) Get(ctx workflow.Context) (*iot.DescribeCACertificateOutput, error) {
	var output iot.DescribeCACertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeCertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeCertificateFuture) Get(ctx workflow.Context) (*iot.DescribeCertificateOutput, error) {
	var output iot.DescribeCertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDefaultAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDefaultAuthorizerFuture) Get(ctx workflow.Context) (*iot.DescribeDefaultAuthorizerOutput, error) {
	var output iot.DescribeDefaultAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDimensionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDimensionFuture) Get(ctx workflow.Context) (*iot.DescribeDimensionOutput, error) {
	var output iot.DescribeDimensionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeDomainConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeDomainConfigurationFuture) Get(ctx workflow.Context) (*iot.DescribeDomainConfigurationOutput, error) {
	var output iot.DescribeDomainConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEndpointFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEndpointFuture) Get(ctx workflow.Context) (*iot.DescribeEndpointOutput, error) {
	var output iot.DescribeEndpointOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeEventConfigurationsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeEventConfigurationsFuture) Get(ctx workflow.Context) (*iot.DescribeEventConfigurationsOutput, error) {
	var output iot.DescribeEventConfigurationsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeIndexFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeIndexFuture) Get(ctx workflow.Context) (*iot.DescribeIndexOutput, error) {
	var output iot.DescribeIndexOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeJobFuture) Get(ctx workflow.Context) (*iot.DescribeJobOutput, error) {
	var output iot.DescribeJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeJobExecutionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeJobExecutionFuture) Get(ctx workflow.Context) (*iot.DescribeJobExecutionOutput, error) {
	var output iot.DescribeJobExecutionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeMitigationActionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeMitigationActionFuture) Get(ctx workflow.Context) (*iot.DescribeMitigationActionOutput, error) {
	var output iot.DescribeMitigationActionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeProvisioningTemplateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeProvisioningTemplateFuture) Get(ctx workflow.Context) (*iot.DescribeProvisioningTemplateOutput, error) {
	var output iot.DescribeProvisioningTemplateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeProvisioningTemplateVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeProvisioningTemplateVersionFuture) Get(ctx workflow.Context) (*iot.DescribeProvisioningTemplateVersionOutput, error) {
	var output iot.DescribeProvisioningTemplateVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeRoleAliasFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeRoleAliasFuture) Get(ctx workflow.Context) (*iot.DescribeRoleAliasOutput, error) {
	var output iot.DescribeRoleAliasOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeScheduledAuditFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeScheduledAuditFuture) Get(ctx workflow.Context) (*iot.DescribeScheduledAuditOutput, error) {
	var output iot.DescribeScheduledAuditOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeSecurityProfileFuture) Get(ctx workflow.Context) (*iot.DescribeSecurityProfileOutput, error) {
	var output iot.DescribeSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeStreamFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeStreamFuture) Get(ctx workflow.Context) (*iot.DescribeStreamOutput, error) {
	var output iot.DescribeStreamOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeThingFuture) Get(ctx workflow.Context) (*iot.DescribeThingOutput, error) {
	var output iot.DescribeThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeThingGroupFuture) Get(ctx workflow.Context) (*iot.DescribeThingGroupOutput, error) {
	var output iot.DescribeThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeThingRegistrationTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeThingRegistrationTaskFuture) Get(ctx workflow.Context) (*iot.DescribeThingRegistrationTaskOutput, error) {
	var output iot.DescribeThingRegistrationTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DescribeThingTypeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DescribeThingTypeFuture) Get(ctx workflow.Context) (*iot.DescribeThingTypeOutput, error) {
	var output iot.DescribeThingTypeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DetachPolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DetachPolicyFuture) Get(ctx workflow.Context) (*iot.DetachPolicyOutput, error) {
	var output iot.DetachPolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DetachPrincipalPolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DetachPrincipalPolicyFuture) Get(ctx workflow.Context) (*iot.DetachPrincipalPolicyOutput, error) {
	var output iot.DetachPrincipalPolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DetachSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DetachSecurityProfileFuture) Get(ctx workflow.Context) (*iot.DetachSecurityProfileOutput, error) {
	var output iot.DetachSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DetachThingPrincipalFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DetachThingPrincipalFuture) Get(ctx workflow.Context) (*iot.DetachThingPrincipalOutput, error) {
	var output iot.DetachThingPrincipalOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type DisableTopicRuleFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *DisableTopicRuleFuture) Get(ctx workflow.Context) (*iot.DisableTopicRuleOutput, error) {
	var output iot.DisableTopicRuleOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type EnableTopicRuleFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *EnableTopicRuleFuture) Get(ctx workflow.Context) (*iot.EnableTopicRuleOutput, error) {
	var output iot.EnableTopicRuleOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetCardinalityFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetCardinalityFuture) Get(ctx workflow.Context) (*iot.GetCardinalityOutput, error) {
	var output iot.GetCardinalityOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetEffectivePoliciesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetEffectivePoliciesFuture) Get(ctx workflow.Context) (*iot.GetEffectivePoliciesOutput, error) {
	var output iot.GetEffectivePoliciesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetIndexingConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetIndexingConfigurationFuture) Get(ctx workflow.Context) (*iot.GetIndexingConfigurationOutput, error) {
	var output iot.GetIndexingConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetJobDocumentFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetJobDocumentFuture) Get(ctx workflow.Context) (*iot.GetJobDocumentOutput, error) {
	var output iot.GetJobDocumentOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetLoggingOptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetLoggingOptionsFuture) Get(ctx workflow.Context) (*iot.GetLoggingOptionsOutput, error) {
	var output iot.GetLoggingOptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetOTAUpdateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetOTAUpdateFuture) Get(ctx workflow.Context) (*iot.GetOTAUpdateOutput, error) {
	var output iot.GetOTAUpdateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetPercentilesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetPercentilesFuture) Get(ctx workflow.Context) (*iot.GetPercentilesOutput, error) {
	var output iot.GetPercentilesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetPolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetPolicyFuture) Get(ctx workflow.Context) (*iot.GetPolicyOutput, error) {
	var output iot.GetPolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetPolicyVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetPolicyVersionFuture) Get(ctx workflow.Context) (*iot.GetPolicyVersionOutput, error) {
	var output iot.GetPolicyVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetRegistrationCodeFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetRegistrationCodeFuture) Get(ctx workflow.Context) (*iot.GetRegistrationCodeOutput, error) {
	var output iot.GetRegistrationCodeOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetStatisticsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetStatisticsFuture) Get(ctx workflow.Context) (*iot.GetStatisticsOutput, error) {
	var output iot.GetStatisticsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetTopicRuleFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetTopicRuleFuture) Get(ctx workflow.Context) (*iot.GetTopicRuleOutput, error) {
	var output iot.GetTopicRuleOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetTopicRuleDestinationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetTopicRuleDestinationFuture) Get(ctx workflow.Context) (*iot.GetTopicRuleDestinationOutput, error) {
	var output iot.GetTopicRuleDestinationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type GetV2LoggingOptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *GetV2LoggingOptionsFuture) Get(ctx workflow.Context) (*iot.GetV2LoggingOptionsOutput, error) {
	var output iot.GetV2LoggingOptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListActiveViolationsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListActiveViolationsFuture) Get(ctx workflow.Context) (*iot.ListActiveViolationsOutput, error) {
	var output iot.ListActiveViolationsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAttachedPoliciesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAttachedPoliciesFuture) Get(ctx workflow.Context) (*iot.ListAttachedPoliciesOutput, error) {
	var output iot.ListAttachedPoliciesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAuditFindingsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAuditFindingsFuture) Get(ctx workflow.Context) (*iot.ListAuditFindingsOutput, error) {
	var output iot.ListAuditFindingsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAuditMitigationActionsExecutionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAuditMitigationActionsExecutionsFuture) Get(ctx workflow.Context) (*iot.ListAuditMitigationActionsExecutionsOutput, error) {
	var output iot.ListAuditMitigationActionsExecutionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAuditMitigationActionsTasksFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAuditMitigationActionsTasksFuture) Get(ctx workflow.Context) (*iot.ListAuditMitigationActionsTasksOutput, error) {
	var output iot.ListAuditMitigationActionsTasksOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAuditSuppressionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAuditSuppressionsFuture) Get(ctx workflow.Context) (*iot.ListAuditSuppressionsOutput, error) {
	var output iot.ListAuditSuppressionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAuditTasksFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAuditTasksFuture) Get(ctx workflow.Context) (*iot.ListAuditTasksOutput, error) {
	var output iot.ListAuditTasksOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListAuthorizersFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListAuthorizersFuture) Get(ctx workflow.Context) (*iot.ListAuthorizersOutput, error) {
	var output iot.ListAuthorizersOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListBillingGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListBillingGroupsFuture) Get(ctx workflow.Context) (*iot.ListBillingGroupsOutput, error) {
	var output iot.ListBillingGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListCACertificatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListCACertificatesFuture) Get(ctx workflow.Context) (*iot.ListCACertificatesOutput, error) {
	var output iot.ListCACertificatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListCertificatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListCertificatesFuture) Get(ctx workflow.Context) (*iot.ListCertificatesOutput, error) {
	var output iot.ListCertificatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListCertificatesByCAFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListCertificatesByCAFuture) Get(ctx workflow.Context) (*iot.ListCertificatesByCAOutput, error) {
	var output iot.ListCertificatesByCAOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListDimensionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListDimensionsFuture) Get(ctx workflow.Context) (*iot.ListDimensionsOutput, error) {
	var output iot.ListDimensionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListDomainConfigurationsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListDomainConfigurationsFuture) Get(ctx workflow.Context) (*iot.ListDomainConfigurationsOutput, error) {
	var output iot.ListDomainConfigurationsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListIndicesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListIndicesFuture) Get(ctx workflow.Context) (*iot.ListIndicesOutput, error) {
	var output iot.ListIndicesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListJobExecutionsForJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListJobExecutionsForJobFuture) Get(ctx workflow.Context) (*iot.ListJobExecutionsForJobOutput, error) {
	var output iot.ListJobExecutionsForJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListJobExecutionsForThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListJobExecutionsForThingFuture) Get(ctx workflow.Context) (*iot.ListJobExecutionsForThingOutput, error) {
	var output iot.ListJobExecutionsForThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListJobsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListJobsFuture) Get(ctx workflow.Context) (*iot.ListJobsOutput, error) {
	var output iot.ListJobsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListMitigationActionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListMitigationActionsFuture) Get(ctx workflow.Context) (*iot.ListMitigationActionsOutput, error) {
	var output iot.ListMitigationActionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListOTAUpdatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListOTAUpdatesFuture) Get(ctx workflow.Context) (*iot.ListOTAUpdatesOutput, error) {
	var output iot.ListOTAUpdatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListOutgoingCertificatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListOutgoingCertificatesFuture) Get(ctx workflow.Context) (*iot.ListOutgoingCertificatesOutput, error) {
	var output iot.ListOutgoingCertificatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListPoliciesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListPoliciesFuture) Get(ctx workflow.Context) (*iot.ListPoliciesOutput, error) {
	var output iot.ListPoliciesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListPolicyPrincipalsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListPolicyPrincipalsFuture) Get(ctx workflow.Context) (*iot.ListPolicyPrincipalsOutput, error) {
	var output iot.ListPolicyPrincipalsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListPolicyVersionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListPolicyVersionsFuture) Get(ctx workflow.Context) (*iot.ListPolicyVersionsOutput, error) {
	var output iot.ListPolicyVersionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListPrincipalPoliciesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListPrincipalPoliciesFuture) Get(ctx workflow.Context) (*iot.ListPrincipalPoliciesOutput, error) {
	var output iot.ListPrincipalPoliciesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListPrincipalThingsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListPrincipalThingsFuture) Get(ctx workflow.Context) (*iot.ListPrincipalThingsOutput, error) {
	var output iot.ListPrincipalThingsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListProvisioningTemplateVersionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListProvisioningTemplateVersionsFuture) Get(ctx workflow.Context) (*iot.ListProvisioningTemplateVersionsOutput, error) {
	var output iot.ListProvisioningTemplateVersionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListProvisioningTemplatesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListProvisioningTemplatesFuture) Get(ctx workflow.Context) (*iot.ListProvisioningTemplatesOutput, error) {
	var output iot.ListProvisioningTemplatesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListRoleAliasesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListRoleAliasesFuture) Get(ctx workflow.Context) (*iot.ListRoleAliasesOutput, error) {
	var output iot.ListRoleAliasesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListScheduledAuditsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListScheduledAuditsFuture) Get(ctx workflow.Context) (*iot.ListScheduledAuditsOutput, error) {
	var output iot.ListScheduledAuditsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListSecurityProfilesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListSecurityProfilesFuture) Get(ctx workflow.Context) (*iot.ListSecurityProfilesOutput, error) {
	var output iot.ListSecurityProfilesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListSecurityProfilesForTargetFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListSecurityProfilesForTargetFuture) Get(ctx workflow.Context) (*iot.ListSecurityProfilesForTargetOutput, error) {
	var output iot.ListSecurityProfilesForTargetOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListStreamsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListStreamsFuture) Get(ctx workflow.Context) (*iot.ListStreamsOutput, error) {
	var output iot.ListStreamsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListTagsForResourceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListTagsForResourceFuture) Get(ctx workflow.Context) (*iot.ListTagsForResourceOutput, error) {
	var output iot.ListTagsForResourceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListTargetsForPolicyFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListTargetsForPolicyFuture) Get(ctx workflow.Context) (*iot.ListTargetsForPolicyOutput, error) {
	var output iot.ListTargetsForPolicyOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListTargetsForSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListTargetsForSecurityProfileFuture) Get(ctx workflow.Context) (*iot.ListTargetsForSecurityProfileOutput, error) {
	var output iot.ListTargetsForSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingGroupsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingGroupsFuture) Get(ctx workflow.Context) (*iot.ListThingGroupsOutput, error) {
	var output iot.ListThingGroupsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingGroupsForThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingGroupsForThingFuture) Get(ctx workflow.Context) (*iot.ListThingGroupsForThingOutput, error) {
	var output iot.ListThingGroupsForThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingPrincipalsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingPrincipalsFuture) Get(ctx workflow.Context) (*iot.ListThingPrincipalsOutput, error) {
	var output iot.ListThingPrincipalsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingRegistrationTaskReportsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingRegistrationTaskReportsFuture) Get(ctx workflow.Context) (*iot.ListThingRegistrationTaskReportsOutput, error) {
	var output iot.ListThingRegistrationTaskReportsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingRegistrationTasksFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingRegistrationTasksFuture) Get(ctx workflow.Context) (*iot.ListThingRegistrationTasksOutput, error) {
	var output iot.ListThingRegistrationTasksOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingTypesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingTypesFuture) Get(ctx workflow.Context) (*iot.ListThingTypesOutput, error) {
	var output iot.ListThingTypesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingsFuture) Get(ctx workflow.Context) (*iot.ListThingsOutput, error) {
	var output iot.ListThingsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingsInBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingsInBillingGroupFuture) Get(ctx workflow.Context) (*iot.ListThingsInBillingGroupOutput, error) {
	var output iot.ListThingsInBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListThingsInThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListThingsInThingGroupFuture) Get(ctx workflow.Context) (*iot.ListThingsInThingGroupOutput, error) {
	var output iot.ListThingsInThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListTopicRuleDestinationsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListTopicRuleDestinationsFuture) Get(ctx workflow.Context) (*iot.ListTopicRuleDestinationsOutput, error) {
	var output iot.ListTopicRuleDestinationsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListTopicRulesFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListTopicRulesFuture) Get(ctx workflow.Context) (*iot.ListTopicRulesOutput, error) {
	var output iot.ListTopicRulesOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListV2LoggingLevelsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListV2LoggingLevelsFuture) Get(ctx workflow.Context) (*iot.ListV2LoggingLevelsOutput, error) {
	var output iot.ListV2LoggingLevelsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ListViolationEventsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ListViolationEventsFuture) Get(ctx workflow.Context) (*iot.ListViolationEventsOutput, error) {
	var output iot.ListViolationEventsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RegisterCACertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RegisterCACertificateFuture) Get(ctx workflow.Context) (*iot.RegisterCACertificateOutput, error) {
	var output iot.RegisterCACertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RegisterCertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RegisterCertificateFuture) Get(ctx workflow.Context) (*iot.RegisterCertificateOutput, error) {
	var output iot.RegisterCertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RegisterCertificateWithoutCAFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RegisterCertificateWithoutCAFuture) Get(ctx workflow.Context) (*iot.RegisterCertificateWithoutCAOutput, error) {
	var output iot.RegisterCertificateWithoutCAOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RegisterThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RegisterThingFuture) Get(ctx workflow.Context) (*iot.RegisterThingOutput, error) {
	var output iot.RegisterThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RejectCertificateTransferFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RejectCertificateTransferFuture) Get(ctx workflow.Context) (*iot.RejectCertificateTransferOutput, error) {
	var output iot.RejectCertificateTransferOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveThingFromBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveThingFromBillingGroupFuture) Get(ctx workflow.Context) (*iot.RemoveThingFromBillingGroupOutput, error) {
	var output iot.RemoveThingFromBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type RemoveThingFromThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *RemoveThingFromThingGroupFuture) Get(ctx workflow.Context) (*iot.RemoveThingFromThingGroupOutput, error) {
	var output iot.RemoveThingFromThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ReplaceTopicRuleFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ReplaceTopicRuleFuture) Get(ctx workflow.Context) (*iot.ReplaceTopicRuleOutput, error) {
	var output iot.ReplaceTopicRuleOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type SearchIndexFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *SearchIndexFuture) Get(ctx workflow.Context) (*iot.SearchIndexOutput, error) {
	var output iot.SearchIndexOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type SetDefaultAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *SetDefaultAuthorizerFuture) Get(ctx workflow.Context) (*iot.SetDefaultAuthorizerOutput, error) {
	var output iot.SetDefaultAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type SetDefaultPolicyVersionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *SetDefaultPolicyVersionFuture) Get(ctx workflow.Context) (*iot.SetDefaultPolicyVersionOutput, error) {
	var output iot.SetDefaultPolicyVersionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type SetLoggingOptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *SetLoggingOptionsFuture) Get(ctx workflow.Context) (*iot.SetLoggingOptionsOutput, error) {
	var output iot.SetLoggingOptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type SetV2LoggingLevelFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *SetV2LoggingLevelFuture) Get(ctx workflow.Context) (*iot.SetV2LoggingLevelOutput, error) {
	var output iot.SetV2LoggingLevelOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type SetV2LoggingOptionsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *SetV2LoggingOptionsFuture) Get(ctx workflow.Context) (*iot.SetV2LoggingOptionsOutput, error) {
	var output iot.SetV2LoggingOptionsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartAuditMitigationActionsTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartAuditMitigationActionsTaskFuture) Get(ctx workflow.Context) (*iot.StartAuditMitigationActionsTaskOutput, error) {
	var output iot.StartAuditMitigationActionsTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartOnDemandAuditTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartOnDemandAuditTaskFuture) Get(ctx workflow.Context) (*iot.StartOnDemandAuditTaskOutput, error) {
	var output iot.StartOnDemandAuditTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StartThingRegistrationTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StartThingRegistrationTaskFuture) Get(ctx workflow.Context) (*iot.StartThingRegistrationTaskOutput, error) {
	var output iot.StartThingRegistrationTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type StopThingRegistrationTaskFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *StopThingRegistrationTaskFuture) Get(ctx workflow.Context) (*iot.StopThingRegistrationTaskOutput, error) {
	var output iot.StopThingRegistrationTaskOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type TagResourceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *TagResourceFuture) Get(ctx workflow.Context) (*iot.TagResourceOutput, error) {
	var output iot.TagResourceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type TestAuthorizationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *TestAuthorizationFuture) Get(ctx workflow.Context) (*iot.TestAuthorizationOutput, error) {
	var output iot.TestAuthorizationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type TestInvokeAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *TestInvokeAuthorizerFuture) Get(ctx workflow.Context) (*iot.TestInvokeAuthorizerOutput, error) {
	var output iot.TestInvokeAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type TransferCertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *TransferCertificateFuture) Get(ctx workflow.Context) (*iot.TransferCertificateOutput, error) {
	var output iot.TransferCertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UntagResourceFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UntagResourceFuture) Get(ctx workflow.Context) (*iot.UntagResourceOutput, error) {
	var output iot.UntagResourceOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateAccountAuditConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateAccountAuditConfigurationFuture) Get(ctx workflow.Context) (*iot.UpdateAccountAuditConfigurationOutput, error) {
	var output iot.UpdateAccountAuditConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateAuditSuppressionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateAuditSuppressionFuture) Get(ctx workflow.Context) (*iot.UpdateAuditSuppressionOutput, error) {
	var output iot.UpdateAuditSuppressionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateAuthorizerFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateAuthorizerFuture) Get(ctx workflow.Context) (*iot.UpdateAuthorizerOutput, error) {
	var output iot.UpdateAuthorizerOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateBillingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateBillingGroupFuture) Get(ctx workflow.Context) (*iot.UpdateBillingGroupOutput, error) {
	var output iot.UpdateBillingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateCACertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateCACertificateFuture) Get(ctx workflow.Context) (*iot.UpdateCACertificateOutput, error) {
	var output iot.UpdateCACertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateCertificateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateCertificateFuture) Get(ctx workflow.Context) (*iot.UpdateCertificateOutput, error) {
	var output iot.UpdateCertificateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateDimensionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateDimensionFuture) Get(ctx workflow.Context) (*iot.UpdateDimensionOutput, error) {
	var output iot.UpdateDimensionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateDomainConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateDomainConfigurationFuture) Get(ctx workflow.Context) (*iot.UpdateDomainConfigurationOutput, error) {
	var output iot.UpdateDomainConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateDynamicThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateDynamicThingGroupFuture) Get(ctx workflow.Context) (*iot.UpdateDynamicThingGroupOutput, error) {
	var output iot.UpdateDynamicThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateEventConfigurationsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateEventConfigurationsFuture) Get(ctx workflow.Context) (*iot.UpdateEventConfigurationsOutput, error) {
	var output iot.UpdateEventConfigurationsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateIndexingConfigurationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateIndexingConfigurationFuture) Get(ctx workflow.Context) (*iot.UpdateIndexingConfigurationOutput, error) {
	var output iot.UpdateIndexingConfigurationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateJobFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateJobFuture) Get(ctx workflow.Context) (*iot.UpdateJobOutput, error) {
	var output iot.UpdateJobOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateMitigationActionFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateMitigationActionFuture) Get(ctx workflow.Context) (*iot.UpdateMitigationActionOutput, error) {
	var output iot.UpdateMitigationActionOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateProvisioningTemplateFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateProvisioningTemplateFuture) Get(ctx workflow.Context) (*iot.UpdateProvisioningTemplateOutput, error) {
	var output iot.UpdateProvisioningTemplateOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateRoleAliasFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateRoleAliasFuture) Get(ctx workflow.Context) (*iot.UpdateRoleAliasOutput, error) {
	var output iot.UpdateRoleAliasOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateScheduledAuditFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateScheduledAuditFuture) Get(ctx workflow.Context) (*iot.UpdateScheduledAuditOutput, error) {
	var output iot.UpdateScheduledAuditOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateSecurityProfileFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateSecurityProfileFuture) Get(ctx workflow.Context) (*iot.UpdateSecurityProfileOutput, error) {
	var output iot.UpdateSecurityProfileOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateStreamFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateStreamFuture) Get(ctx workflow.Context) (*iot.UpdateStreamOutput, error) {
	var output iot.UpdateStreamOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateThingFuture) Get(ctx workflow.Context) (*iot.UpdateThingOutput, error) {
	var output iot.UpdateThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateThingGroupFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateThingGroupFuture) Get(ctx workflow.Context) (*iot.UpdateThingGroupOutput, error) {
	var output iot.UpdateThingGroupOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateThingGroupsForThingFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateThingGroupsForThingFuture) Get(ctx workflow.Context) (*iot.UpdateThingGroupsForThingOutput, error) {
	var output iot.UpdateThingGroupsForThingOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type UpdateTopicRuleDestinationFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *UpdateTopicRuleDestinationFuture) Get(ctx workflow.Context) (*iot.UpdateTopicRuleDestinationOutput, error) {
	var output iot.UpdateTopicRuleDestinationOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

type ValidateSecurityProfileBehaviorsFuture struct {
	// public to support Selector.addFuture
	Future workflow.Future
}

func (r *ValidateSecurityProfileBehaviorsFuture) Get(ctx workflow.Context) (*iot.ValidateSecurityProfileBehaviorsOutput, error) {
	var output iot.ValidateSecurityProfileBehaviorsOutput
	err := r.Future.Get(ctx, &output)
	return &output, err
}

func (a *stub) AcceptCertificateTransfer(ctx workflow.Context, input *iot.AcceptCertificateTransferInput) (*iot.AcceptCertificateTransferOutput, error) {
	var output iot.AcceptCertificateTransferOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AcceptCertificateTransfer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AcceptCertificateTransferAsync(ctx workflow.Context, input *iot.AcceptCertificateTransferInput) *AcceptCertificateTransferFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AcceptCertificateTransfer", input)
	return &AcceptCertificateTransferFuture{Future: future}
}

func (a *stub) AddThingToBillingGroup(ctx workflow.Context, input *iot.AddThingToBillingGroupInput) (*iot.AddThingToBillingGroupOutput, error) {
	var output iot.AddThingToBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AddThingToBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AddThingToBillingGroupAsync(ctx workflow.Context, input *iot.AddThingToBillingGroupInput) *AddThingToBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AddThingToBillingGroup", input)
	return &AddThingToBillingGroupFuture{Future: future}
}

func (a *stub) AddThingToThingGroup(ctx workflow.Context, input *iot.AddThingToThingGroupInput) (*iot.AddThingToThingGroupOutput, error) {
	var output iot.AddThingToThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AddThingToThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AddThingToThingGroupAsync(ctx workflow.Context, input *iot.AddThingToThingGroupInput) *AddThingToThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AddThingToThingGroup", input)
	return &AddThingToThingGroupFuture{Future: future}
}

func (a *stub) AssociateTargetsWithJob(ctx workflow.Context, input *iot.AssociateTargetsWithJobInput) (*iot.AssociateTargetsWithJobOutput, error) {
	var output iot.AssociateTargetsWithJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AssociateTargetsWithJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AssociateTargetsWithJobAsync(ctx workflow.Context, input *iot.AssociateTargetsWithJobInput) *AssociateTargetsWithJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AssociateTargetsWithJob", input)
	return &AssociateTargetsWithJobFuture{Future: future}
}

func (a *stub) AttachPolicy(ctx workflow.Context, input *iot.AttachPolicyInput) (*iot.AttachPolicyOutput, error) {
	var output iot.AttachPolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AttachPolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AttachPolicyAsync(ctx workflow.Context, input *iot.AttachPolicyInput) *AttachPolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AttachPolicy", input)
	return &AttachPolicyFuture{Future: future}
}

func (a *stub) AttachPrincipalPolicy(ctx workflow.Context, input *iot.AttachPrincipalPolicyInput) (*iot.AttachPrincipalPolicyOutput, error) {
	var output iot.AttachPrincipalPolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AttachPrincipalPolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AttachPrincipalPolicyAsync(ctx workflow.Context, input *iot.AttachPrincipalPolicyInput) *AttachPrincipalPolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AttachPrincipalPolicy", input)
	return &AttachPrincipalPolicyFuture{Future: future}
}

func (a *stub) AttachSecurityProfile(ctx workflow.Context, input *iot.AttachSecurityProfileInput) (*iot.AttachSecurityProfileOutput, error) {
	var output iot.AttachSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AttachSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AttachSecurityProfileAsync(ctx workflow.Context, input *iot.AttachSecurityProfileInput) *AttachSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AttachSecurityProfile", input)
	return &AttachSecurityProfileFuture{Future: future}
}

func (a *stub) AttachThingPrincipal(ctx workflow.Context, input *iot.AttachThingPrincipalInput) (*iot.AttachThingPrincipalOutput, error) {
	var output iot.AttachThingPrincipalOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.AttachThingPrincipal", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) AttachThingPrincipalAsync(ctx workflow.Context, input *iot.AttachThingPrincipalInput) *AttachThingPrincipalFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.AttachThingPrincipal", input)
	return &AttachThingPrincipalFuture{Future: future}
}

func (a *stub) CancelAuditMitigationActionsTask(ctx workflow.Context, input *iot.CancelAuditMitigationActionsTaskInput) (*iot.CancelAuditMitigationActionsTaskOutput, error) {
	var output iot.CancelAuditMitigationActionsTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CancelAuditMitigationActionsTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CancelAuditMitigationActionsTaskAsync(ctx workflow.Context, input *iot.CancelAuditMitigationActionsTaskInput) *CancelAuditMitigationActionsTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CancelAuditMitigationActionsTask", input)
	return &CancelAuditMitigationActionsTaskFuture{Future: future}
}

func (a *stub) CancelAuditTask(ctx workflow.Context, input *iot.CancelAuditTaskInput) (*iot.CancelAuditTaskOutput, error) {
	var output iot.CancelAuditTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CancelAuditTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CancelAuditTaskAsync(ctx workflow.Context, input *iot.CancelAuditTaskInput) *CancelAuditTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CancelAuditTask", input)
	return &CancelAuditTaskFuture{Future: future}
}

func (a *stub) CancelCertificateTransfer(ctx workflow.Context, input *iot.CancelCertificateTransferInput) (*iot.CancelCertificateTransferOutput, error) {
	var output iot.CancelCertificateTransferOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CancelCertificateTransfer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CancelCertificateTransferAsync(ctx workflow.Context, input *iot.CancelCertificateTransferInput) *CancelCertificateTransferFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CancelCertificateTransfer", input)
	return &CancelCertificateTransferFuture{Future: future}
}

func (a *stub) CancelJob(ctx workflow.Context, input *iot.CancelJobInput) (*iot.CancelJobOutput, error) {
	var output iot.CancelJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CancelJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CancelJobAsync(ctx workflow.Context, input *iot.CancelJobInput) *CancelJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CancelJob", input)
	return &CancelJobFuture{Future: future}
}

func (a *stub) CancelJobExecution(ctx workflow.Context, input *iot.CancelJobExecutionInput) (*iot.CancelJobExecutionOutput, error) {
	var output iot.CancelJobExecutionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CancelJobExecution", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CancelJobExecutionAsync(ctx workflow.Context, input *iot.CancelJobExecutionInput) *CancelJobExecutionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CancelJobExecution", input)
	return &CancelJobExecutionFuture{Future: future}
}

func (a *stub) ClearDefaultAuthorizer(ctx workflow.Context, input *iot.ClearDefaultAuthorizerInput) (*iot.ClearDefaultAuthorizerOutput, error) {
	var output iot.ClearDefaultAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ClearDefaultAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ClearDefaultAuthorizerAsync(ctx workflow.Context, input *iot.ClearDefaultAuthorizerInput) *ClearDefaultAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ClearDefaultAuthorizer", input)
	return &ClearDefaultAuthorizerFuture{Future: future}
}

func (a *stub) ConfirmTopicRuleDestination(ctx workflow.Context, input *iot.ConfirmTopicRuleDestinationInput) (*iot.ConfirmTopicRuleDestinationOutput, error) {
	var output iot.ConfirmTopicRuleDestinationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ConfirmTopicRuleDestination", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ConfirmTopicRuleDestinationAsync(ctx workflow.Context, input *iot.ConfirmTopicRuleDestinationInput) *ConfirmTopicRuleDestinationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ConfirmTopicRuleDestination", input)
	return &ConfirmTopicRuleDestinationFuture{Future: future}
}

func (a *stub) CreateAuditSuppression(ctx workflow.Context, input *iot.CreateAuditSuppressionInput) (*iot.CreateAuditSuppressionOutput, error) {
	var output iot.CreateAuditSuppressionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateAuditSuppression", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateAuditSuppressionAsync(ctx workflow.Context, input *iot.CreateAuditSuppressionInput) *CreateAuditSuppressionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateAuditSuppression", input)
	return &CreateAuditSuppressionFuture{Future: future}
}

func (a *stub) CreateAuthorizer(ctx workflow.Context, input *iot.CreateAuthorizerInput) (*iot.CreateAuthorizerOutput, error) {
	var output iot.CreateAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateAuthorizerAsync(ctx workflow.Context, input *iot.CreateAuthorizerInput) *CreateAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateAuthorizer", input)
	return &CreateAuthorizerFuture{Future: future}
}

func (a *stub) CreateBillingGroup(ctx workflow.Context, input *iot.CreateBillingGroupInput) (*iot.CreateBillingGroupOutput, error) {
	var output iot.CreateBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateBillingGroupAsync(ctx workflow.Context, input *iot.CreateBillingGroupInput) *CreateBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateBillingGroup", input)
	return &CreateBillingGroupFuture{Future: future}
}

func (a *stub) CreateCertificateFromCsr(ctx workflow.Context, input *iot.CreateCertificateFromCsrInput) (*iot.CreateCertificateFromCsrOutput, error) {
	var output iot.CreateCertificateFromCsrOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateCertificateFromCsr", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateCertificateFromCsrAsync(ctx workflow.Context, input *iot.CreateCertificateFromCsrInput) *CreateCertificateFromCsrFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateCertificateFromCsr", input)
	return &CreateCertificateFromCsrFuture{Future: future}
}

func (a *stub) CreateDimension(ctx workflow.Context, input *iot.CreateDimensionInput) (*iot.CreateDimensionOutput, error) {
	var output iot.CreateDimensionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateDimension", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDimensionAsync(ctx workflow.Context, input *iot.CreateDimensionInput) *CreateDimensionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateDimension", input)
	return &CreateDimensionFuture{Future: future}
}

func (a *stub) CreateDomainConfiguration(ctx workflow.Context, input *iot.CreateDomainConfigurationInput) (*iot.CreateDomainConfigurationOutput, error) {
	var output iot.CreateDomainConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateDomainConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDomainConfigurationAsync(ctx workflow.Context, input *iot.CreateDomainConfigurationInput) *CreateDomainConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateDomainConfiguration", input)
	return &CreateDomainConfigurationFuture{Future: future}
}

func (a *stub) CreateDynamicThingGroup(ctx workflow.Context, input *iot.CreateDynamicThingGroupInput) (*iot.CreateDynamicThingGroupOutput, error) {
	var output iot.CreateDynamicThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateDynamicThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateDynamicThingGroupAsync(ctx workflow.Context, input *iot.CreateDynamicThingGroupInput) *CreateDynamicThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateDynamicThingGroup", input)
	return &CreateDynamicThingGroupFuture{Future: future}
}

func (a *stub) CreateJob(ctx workflow.Context, input *iot.CreateJobInput) (*iot.CreateJobOutput, error) {
	var output iot.CreateJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateJobAsync(ctx workflow.Context, input *iot.CreateJobInput) *CreateJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateJob", input)
	return &CreateJobFuture{Future: future}
}

func (a *stub) CreateKeysAndCertificate(ctx workflow.Context, input *iot.CreateKeysAndCertificateInput) (*iot.CreateKeysAndCertificateOutput, error) {
	var output iot.CreateKeysAndCertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateKeysAndCertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateKeysAndCertificateAsync(ctx workflow.Context, input *iot.CreateKeysAndCertificateInput) *CreateKeysAndCertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateKeysAndCertificate", input)
	return &CreateKeysAndCertificateFuture{Future: future}
}

func (a *stub) CreateMitigationAction(ctx workflow.Context, input *iot.CreateMitigationActionInput) (*iot.CreateMitigationActionOutput, error) {
	var output iot.CreateMitigationActionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateMitigationAction", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateMitigationActionAsync(ctx workflow.Context, input *iot.CreateMitigationActionInput) *CreateMitigationActionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateMitigationAction", input)
	return &CreateMitigationActionFuture{Future: future}
}

func (a *stub) CreateOTAUpdate(ctx workflow.Context, input *iot.CreateOTAUpdateInput) (*iot.CreateOTAUpdateOutput, error) {
	var output iot.CreateOTAUpdateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateOTAUpdate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateOTAUpdateAsync(ctx workflow.Context, input *iot.CreateOTAUpdateInput) *CreateOTAUpdateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateOTAUpdate", input)
	return &CreateOTAUpdateFuture{Future: future}
}

func (a *stub) CreatePolicy(ctx workflow.Context, input *iot.CreatePolicyInput) (*iot.CreatePolicyOutput, error) {
	var output iot.CreatePolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreatePolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreatePolicyAsync(ctx workflow.Context, input *iot.CreatePolicyInput) *CreatePolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreatePolicy", input)
	return &CreatePolicyFuture{Future: future}
}

func (a *stub) CreatePolicyVersion(ctx workflow.Context, input *iot.CreatePolicyVersionInput) (*iot.CreatePolicyVersionOutput, error) {
	var output iot.CreatePolicyVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreatePolicyVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreatePolicyVersionAsync(ctx workflow.Context, input *iot.CreatePolicyVersionInput) *CreatePolicyVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreatePolicyVersion", input)
	return &CreatePolicyVersionFuture{Future: future}
}

func (a *stub) CreateProvisioningClaim(ctx workflow.Context, input *iot.CreateProvisioningClaimInput) (*iot.CreateProvisioningClaimOutput, error) {
	var output iot.CreateProvisioningClaimOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateProvisioningClaim", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateProvisioningClaimAsync(ctx workflow.Context, input *iot.CreateProvisioningClaimInput) *CreateProvisioningClaimFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateProvisioningClaim", input)
	return &CreateProvisioningClaimFuture{Future: future}
}

func (a *stub) CreateProvisioningTemplate(ctx workflow.Context, input *iot.CreateProvisioningTemplateInput) (*iot.CreateProvisioningTemplateOutput, error) {
	var output iot.CreateProvisioningTemplateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateProvisioningTemplate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateProvisioningTemplateAsync(ctx workflow.Context, input *iot.CreateProvisioningTemplateInput) *CreateProvisioningTemplateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateProvisioningTemplate", input)
	return &CreateProvisioningTemplateFuture{Future: future}
}

func (a *stub) CreateProvisioningTemplateVersion(ctx workflow.Context, input *iot.CreateProvisioningTemplateVersionInput) (*iot.CreateProvisioningTemplateVersionOutput, error) {
	var output iot.CreateProvisioningTemplateVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateProvisioningTemplateVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateProvisioningTemplateVersionAsync(ctx workflow.Context, input *iot.CreateProvisioningTemplateVersionInput) *CreateProvisioningTemplateVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateProvisioningTemplateVersion", input)
	return &CreateProvisioningTemplateVersionFuture{Future: future}
}

func (a *stub) CreateRoleAlias(ctx workflow.Context, input *iot.CreateRoleAliasInput) (*iot.CreateRoleAliasOutput, error) {
	var output iot.CreateRoleAliasOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateRoleAlias", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateRoleAliasAsync(ctx workflow.Context, input *iot.CreateRoleAliasInput) *CreateRoleAliasFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateRoleAlias", input)
	return &CreateRoleAliasFuture{Future: future}
}

func (a *stub) CreateScheduledAudit(ctx workflow.Context, input *iot.CreateScheduledAuditInput) (*iot.CreateScheduledAuditOutput, error) {
	var output iot.CreateScheduledAuditOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateScheduledAudit", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateScheduledAuditAsync(ctx workflow.Context, input *iot.CreateScheduledAuditInput) *CreateScheduledAuditFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateScheduledAudit", input)
	return &CreateScheduledAuditFuture{Future: future}
}

func (a *stub) CreateSecurityProfile(ctx workflow.Context, input *iot.CreateSecurityProfileInput) (*iot.CreateSecurityProfileOutput, error) {
	var output iot.CreateSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateSecurityProfileAsync(ctx workflow.Context, input *iot.CreateSecurityProfileInput) *CreateSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateSecurityProfile", input)
	return &CreateSecurityProfileFuture{Future: future}
}

func (a *stub) CreateStream(ctx workflow.Context, input *iot.CreateStreamInput) (*iot.CreateStreamOutput, error) {
	var output iot.CreateStreamOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateStream", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateStreamAsync(ctx workflow.Context, input *iot.CreateStreamInput) *CreateStreamFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateStream", input)
	return &CreateStreamFuture{Future: future}
}

func (a *stub) CreateThing(ctx workflow.Context, input *iot.CreateThingInput) (*iot.CreateThingOutput, error) {
	var output iot.CreateThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateThingAsync(ctx workflow.Context, input *iot.CreateThingInput) *CreateThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateThing", input)
	return &CreateThingFuture{Future: future}
}

func (a *stub) CreateThingGroup(ctx workflow.Context, input *iot.CreateThingGroupInput) (*iot.CreateThingGroupOutput, error) {
	var output iot.CreateThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateThingGroupAsync(ctx workflow.Context, input *iot.CreateThingGroupInput) *CreateThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateThingGroup", input)
	return &CreateThingGroupFuture{Future: future}
}

func (a *stub) CreateThingType(ctx workflow.Context, input *iot.CreateThingTypeInput) (*iot.CreateThingTypeOutput, error) {
	var output iot.CreateThingTypeOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateThingType", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateThingTypeAsync(ctx workflow.Context, input *iot.CreateThingTypeInput) *CreateThingTypeFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateThingType", input)
	return &CreateThingTypeFuture{Future: future}
}

func (a *stub) CreateTopicRule(ctx workflow.Context, input *iot.CreateTopicRuleInput) (*iot.CreateTopicRuleOutput, error) {
	var output iot.CreateTopicRuleOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateTopicRule", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateTopicRuleAsync(ctx workflow.Context, input *iot.CreateTopicRuleInput) *CreateTopicRuleFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateTopicRule", input)
	return &CreateTopicRuleFuture{Future: future}
}

func (a *stub) CreateTopicRuleDestination(ctx workflow.Context, input *iot.CreateTopicRuleDestinationInput) (*iot.CreateTopicRuleDestinationOutput, error) {
	var output iot.CreateTopicRuleDestinationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.CreateTopicRuleDestination", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) CreateTopicRuleDestinationAsync(ctx workflow.Context, input *iot.CreateTopicRuleDestinationInput) *CreateTopicRuleDestinationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.CreateTopicRuleDestination", input)
	return &CreateTopicRuleDestinationFuture{Future: future}
}

func (a *stub) DeleteAccountAuditConfiguration(ctx workflow.Context, input *iot.DeleteAccountAuditConfigurationInput) (*iot.DeleteAccountAuditConfigurationOutput, error) {
	var output iot.DeleteAccountAuditConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteAccountAuditConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteAccountAuditConfigurationAsync(ctx workflow.Context, input *iot.DeleteAccountAuditConfigurationInput) *DeleteAccountAuditConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteAccountAuditConfiguration", input)
	return &DeleteAccountAuditConfigurationFuture{Future: future}
}

func (a *stub) DeleteAuditSuppression(ctx workflow.Context, input *iot.DeleteAuditSuppressionInput) (*iot.DeleteAuditSuppressionOutput, error) {
	var output iot.DeleteAuditSuppressionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteAuditSuppression", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteAuditSuppressionAsync(ctx workflow.Context, input *iot.DeleteAuditSuppressionInput) *DeleteAuditSuppressionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteAuditSuppression", input)
	return &DeleteAuditSuppressionFuture{Future: future}
}

func (a *stub) DeleteAuthorizer(ctx workflow.Context, input *iot.DeleteAuthorizerInput) (*iot.DeleteAuthorizerOutput, error) {
	var output iot.DeleteAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteAuthorizerAsync(ctx workflow.Context, input *iot.DeleteAuthorizerInput) *DeleteAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteAuthorizer", input)
	return &DeleteAuthorizerFuture{Future: future}
}

func (a *stub) DeleteBillingGroup(ctx workflow.Context, input *iot.DeleteBillingGroupInput) (*iot.DeleteBillingGroupOutput, error) {
	var output iot.DeleteBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteBillingGroupAsync(ctx workflow.Context, input *iot.DeleteBillingGroupInput) *DeleteBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteBillingGroup", input)
	return &DeleteBillingGroupFuture{Future: future}
}

func (a *stub) DeleteCACertificate(ctx workflow.Context, input *iot.DeleteCACertificateInput) (*iot.DeleteCACertificateOutput, error) {
	var output iot.DeleteCACertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteCACertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteCACertificateAsync(ctx workflow.Context, input *iot.DeleteCACertificateInput) *DeleteCACertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteCACertificate", input)
	return &DeleteCACertificateFuture{Future: future}
}

func (a *stub) DeleteCertificate(ctx workflow.Context, input *iot.DeleteCertificateInput) (*iot.DeleteCertificateOutput, error) {
	var output iot.DeleteCertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteCertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteCertificateAsync(ctx workflow.Context, input *iot.DeleteCertificateInput) *DeleteCertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteCertificate", input)
	return &DeleteCertificateFuture{Future: future}
}

func (a *stub) DeleteDimension(ctx workflow.Context, input *iot.DeleteDimensionInput) (*iot.DeleteDimensionOutput, error) {
	var output iot.DeleteDimensionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteDimension", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDimensionAsync(ctx workflow.Context, input *iot.DeleteDimensionInput) *DeleteDimensionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteDimension", input)
	return &DeleteDimensionFuture{Future: future}
}

func (a *stub) DeleteDomainConfiguration(ctx workflow.Context, input *iot.DeleteDomainConfigurationInput) (*iot.DeleteDomainConfigurationOutput, error) {
	var output iot.DeleteDomainConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteDomainConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDomainConfigurationAsync(ctx workflow.Context, input *iot.DeleteDomainConfigurationInput) *DeleteDomainConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteDomainConfiguration", input)
	return &DeleteDomainConfigurationFuture{Future: future}
}

func (a *stub) DeleteDynamicThingGroup(ctx workflow.Context, input *iot.DeleteDynamicThingGroupInput) (*iot.DeleteDynamicThingGroupOutput, error) {
	var output iot.DeleteDynamicThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteDynamicThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteDynamicThingGroupAsync(ctx workflow.Context, input *iot.DeleteDynamicThingGroupInput) *DeleteDynamicThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteDynamicThingGroup", input)
	return &DeleteDynamicThingGroupFuture{Future: future}
}

func (a *stub) DeleteJob(ctx workflow.Context, input *iot.DeleteJobInput) (*iot.DeleteJobOutput, error) {
	var output iot.DeleteJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteJobAsync(ctx workflow.Context, input *iot.DeleteJobInput) *DeleteJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteJob", input)
	return &DeleteJobFuture{Future: future}
}

func (a *stub) DeleteJobExecution(ctx workflow.Context, input *iot.DeleteJobExecutionInput) (*iot.DeleteJobExecutionOutput, error) {
	var output iot.DeleteJobExecutionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteJobExecution", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteJobExecutionAsync(ctx workflow.Context, input *iot.DeleteJobExecutionInput) *DeleteJobExecutionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteJobExecution", input)
	return &DeleteJobExecutionFuture{Future: future}
}

func (a *stub) DeleteMitigationAction(ctx workflow.Context, input *iot.DeleteMitigationActionInput) (*iot.DeleteMitigationActionOutput, error) {
	var output iot.DeleteMitigationActionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteMitigationAction", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteMitigationActionAsync(ctx workflow.Context, input *iot.DeleteMitigationActionInput) *DeleteMitigationActionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteMitigationAction", input)
	return &DeleteMitigationActionFuture{Future: future}
}

func (a *stub) DeleteOTAUpdate(ctx workflow.Context, input *iot.DeleteOTAUpdateInput) (*iot.DeleteOTAUpdateOutput, error) {
	var output iot.DeleteOTAUpdateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteOTAUpdate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteOTAUpdateAsync(ctx workflow.Context, input *iot.DeleteOTAUpdateInput) *DeleteOTAUpdateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteOTAUpdate", input)
	return &DeleteOTAUpdateFuture{Future: future}
}

func (a *stub) DeletePolicy(ctx workflow.Context, input *iot.DeletePolicyInput) (*iot.DeletePolicyOutput, error) {
	var output iot.DeletePolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeletePolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeletePolicyAsync(ctx workflow.Context, input *iot.DeletePolicyInput) *DeletePolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeletePolicy", input)
	return &DeletePolicyFuture{Future: future}
}

func (a *stub) DeletePolicyVersion(ctx workflow.Context, input *iot.DeletePolicyVersionInput) (*iot.DeletePolicyVersionOutput, error) {
	var output iot.DeletePolicyVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeletePolicyVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeletePolicyVersionAsync(ctx workflow.Context, input *iot.DeletePolicyVersionInput) *DeletePolicyVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeletePolicyVersion", input)
	return &DeletePolicyVersionFuture{Future: future}
}

func (a *stub) DeleteProvisioningTemplate(ctx workflow.Context, input *iot.DeleteProvisioningTemplateInput) (*iot.DeleteProvisioningTemplateOutput, error) {
	var output iot.DeleteProvisioningTemplateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteProvisioningTemplate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteProvisioningTemplateAsync(ctx workflow.Context, input *iot.DeleteProvisioningTemplateInput) *DeleteProvisioningTemplateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteProvisioningTemplate", input)
	return &DeleteProvisioningTemplateFuture{Future: future}
}

func (a *stub) DeleteProvisioningTemplateVersion(ctx workflow.Context, input *iot.DeleteProvisioningTemplateVersionInput) (*iot.DeleteProvisioningTemplateVersionOutput, error) {
	var output iot.DeleteProvisioningTemplateVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteProvisioningTemplateVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteProvisioningTemplateVersionAsync(ctx workflow.Context, input *iot.DeleteProvisioningTemplateVersionInput) *DeleteProvisioningTemplateVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteProvisioningTemplateVersion", input)
	return &DeleteProvisioningTemplateVersionFuture{Future: future}
}

func (a *stub) DeleteRegistrationCode(ctx workflow.Context, input *iot.DeleteRegistrationCodeInput) (*iot.DeleteRegistrationCodeOutput, error) {
	var output iot.DeleteRegistrationCodeOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteRegistrationCode", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteRegistrationCodeAsync(ctx workflow.Context, input *iot.DeleteRegistrationCodeInput) *DeleteRegistrationCodeFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteRegistrationCode", input)
	return &DeleteRegistrationCodeFuture{Future: future}
}

func (a *stub) DeleteRoleAlias(ctx workflow.Context, input *iot.DeleteRoleAliasInput) (*iot.DeleteRoleAliasOutput, error) {
	var output iot.DeleteRoleAliasOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteRoleAlias", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteRoleAliasAsync(ctx workflow.Context, input *iot.DeleteRoleAliasInput) *DeleteRoleAliasFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteRoleAlias", input)
	return &DeleteRoleAliasFuture{Future: future}
}

func (a *stub) DeleteScheduledAudit(ctx workflow.Context, input *iot.DeleteScheduledAuditInput) (*iot.DeleteScheduledAuditOutput, error) {
	var output iot.DeleteScheduledAuditOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteScheduledAudit", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteScheduledAuditAsync(ctx workflow.Context, input *iot.DeleteScheduledAuditInput) *DeleteScheduledAuditFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteScheduledAudit", input)
	return &DeleteScheduledAuditFuture{Future: future}
}

func (a *stub) DeleteSecurityProfile(ctx workflow.Context, input *iot.DeleteSecurityProfileInput) (*iot.DeleteSecurityProfileOutput, error) {
	var output iot.DeleteSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteSecurityProfileAsync(ctx workflow.Context, input *iot.DeleteSecurityProfileInput) *DeleteSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteSecurityProfile", input)
	return &DeleteSecurityProfileFuture{Future: future}
}

func (a *stub) DeleteStream(ctx workflow.Context, input *iot.DeleteStreamInput) (*iot.DeleteStreamOutput, error) {
	var output iot.DeleteStreamOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteStream", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteStreamAsync(ctx workflow.Context, input *iot.DeleteStreamInput) *DeleteStreamFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteStream", input)
	return &DeleteStreamFuture{Future: future}
}

func (a *stub) DeleteThing(ctx workflow.Context, input *iot.DeleteThingInput) (*iot.DeleteThingOutput, error) {
	var output iot.DeleteThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteThingAsync(ctx workflow.Context, input *iot.DeleteThingInput) *DeleteThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteThing", input)
	return &DeleteThingFuture{Future: future}
}

func (a *stub) DeleteThingGroup(ctx workflow.Context, input *iot.DeleteThingGroupInput) (*iot.DeleteThingGroupOutput, error) {
	var output iot.DeleteThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteThingGroupAsync(ctx workflow.Context, input *iot.DeleteThingGroupInput) *DeleteThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteThingGroup", input)
	return &DeleteThingGroupFuture{Future: future}
}

func (a *stub) DeleteThingType(ctx workflow.Context, input *iot.DeleteThingTypeInput) (*iot.DeleteThingTypeOutput, error) {
	var output iot.DeleteThingTypeOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteThingType", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteThingTypeAsync(ctx workflow.Context, input *iot.DeleteThingTypeInput) *DeleteThingTypeFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteThingType", input)
	return &DeleteThingTypeFuture{Future: future}
}

func (a *stub) DeleteTopicRule(ctx workflow.Context, input *iot.DeleteTopicRuleInput) (*iot.DeleteTopicRuleOutput, error) {
	var output iot.DeleteTopicRuleOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteTopicRule", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteTopicRuleAsync(ctx workflow.Context, input *iot.DeleteTopicRuleInput) *DeleteTopicRuleFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteTopicRule", input)
	return &DeleteTopicRuleFuture{Future: future}
}

func (a *stub) DeleteTopicRuleDestination(ctx workflow.Context, input *iot.DeleteTopicRuleDestinationInput) (*iot.DeleteTopicRuleDestinationOutput, error) {
	var output iot.DeleteTopicRuleDestinationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteTopicRuleDestination", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteTopicRuleDestinationAsync(ctx workflow.Context, input *iot.DeleteTopicRuleDestinationInput) *DeleteTopicRuleDestinationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteTopicRuleDestination", input)
	return &DeleteTopicRuleDestinationFuture{Future: future}
}

func (a *stub) DeleteV2LoggingLevel(ctx workflow.Context, input *iot.DeleteV2LoggingLevelInput) (*iot.DeleteV2LoggingLevelOutput, error) {
	var output iot.DeleteV2LoggingLevelOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeleteV2LoggingLevel", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeleteV2LoggingLevelAsync(ctx workflow.Context, input *iot.DeleteV2LoggingLevelInput) *DeleteV2LoggingLevelFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeleteV2LoggingLevel", input)
	return &DeleteV2LoggingLevelFuture{Future: future}
}

func (a *stub) DeprecateThingType(ctx workflow.Context, input *iot.DeprecateThingTypeInput) (*iot.DeprecateThingTypeOutput, error) {
	var output iot.DeprecateThingTypeOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DeprecateThingType", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DeprecateThingTypeAsync(ctx workflow.Context, input *iot.DeprecateThingTypeInput) *DeprecateThingTypeFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DeprecateThingType", input)
	return &DeprecateThingTypeFuture{Future: future}
}

func (a *stub) DescribeAccountAuditConfiguration(ctx workflow.Context, input *iot.DescribeAccountAuditConfigurationInput) (*iot.DescribeAccountAuditConfigurationOutput, error) {
	var output iot.DescribeAccountAuditConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAccountAuditConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAccountAuditConfigurationAsync(ctx workflow.Context, input *iot.DescribeAccountAuditConfigurationInput) *DescribeAccountAuditConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAccountAuditConfiguration", input)
	return &DescribeAccountAuditConfigurationFuture{Future: future}
}

func (a *stub) DescribeAuditFinding(ctx workflow.Context, input *iot.DescribeAuditFindingInput) (*iot.DescribeAuditFindingOutput, error) {
	var output iot.DescribeAuditFindingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditFinding", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAuditFindingAsync(ctx workflow.Context, input *iot.DescribeAuditFindingInput) *DescribeAuditFindingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditFinding", input)
	return &DescribeAuditFindingFuture{Future: future}
}

func (a *stub) DescribeAuditMitigationActionsTask(ctx workflow.Context, input *iot.DescribeAuditMitigationActionsTaskInput) (*iot.DescribeAuditMitigationActionsTaskOutput, error) {
	var output iot.DescribeAuditMitigationActionsTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditMitigationActionsTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAuditMitigationActionsTaskAsync(ctx workflow.Context, input *iot.DescribeAuditMitigationActionsTaskInput) *DescribeAuditMitigationActionsTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditMitigationActionsTask", input)
	return &DescribeAuditMitigationActionsTaskFuture{Future: future}
}

func (a *stub) DescribeAuditSuppression(ctx workflow.Context, input *iot.DescribeAuditSuppressionInput) (*iot.DescribeAuditSuppressionOutput, error) {
	var output iot.DescribeAuditSuppressionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditSuppression", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAuditSuppressionAsync(ctx workflow.Context, input *iot.DescribeAuditSuppressionInput) *DescribeAuditSuppressionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditSuppression", input)
	return &DescribeAuditSuppressionFuture{Future: future}
}

func (a *stub) DescribeAuditTask(ctx workflow.Context, input *iot.DescribeAuditTaskInput) (*iot.DescribeAuditTaskOutput, error) {
	var output iot.DescribeAuditTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAuditTaskAsync(ctx workflow.Context, input *iot.DescribeAuditTaskInput) *DescribeAuditTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuditTask", input)
	return &DescribeAuditTaskFuture{Future: future}
}

func (a *stub) DescribeAuthorizer(ctx workflow.Context, input *iot.DescribeAuthorizerInput) (*iot.DescribeAuthorizerOutput, error) {
	var output iot.DescribeAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeAuthorizerAsync(ctx workflow.Context, input *iot.DescribeAuthorizerInput) *DescribeAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeAuthorizer", input)
	return &DescribeAuthorizerFuture{Future: future}
}

func (a *stub) DescribeBillingGroup(ctx workflow.Context, input *iot.DescribeBillingGroupInput) (*iot.DescribeBillingGroupOutput, error) {
	var output iot.DescribeBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeBillingGroupAsync(ctx workflow.Context, input *iot.DescribeBillingGroupInput) *DescribeBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeBillingGroup", input)
	return &DescribeBillingGroupFuture{Future: future}
}

func (a *stub) DescribeCACertificate(ctx workflow.Context, input *iot.DescribeCACertificateInput) (*iot.DescribeCACertificateOutput, error) {
	var output iot.DescribeCACertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeCACertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeCACertificateAsync(ctx workflow.Context, input *iot.DescribeCACertificateInput) *DescribeCACertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeCACertificate", input)
	return &DescribeCACertificateFuture{Future: future}
}

func (a *stub) DescribeCertificate(ctx workflow.Context, input *iot.DescribeCertificateInput) (*iot.DescribeCertificateOutput, error) {
	var output iot.DescribeCertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeCertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeCertificateAsync(ctx workflow.Context, input *iot.DescribeCertificateInput) *DescribeCertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeCertificate", input)
	return &DescribeCertificateFuture{Future: future}
}

func (a *stub) DescribeDefaultAuthorizer(ctx workflow.Context, input *iot.DescribeDefaultAuthorizerInput) (*iot.DescribeDefaultAuthorizerOutput, error) {
	var output iot.DescribeDefaultAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeDefaultAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDefaultAuthorizerAsync(ctx workflow.Context, input *iot.DescribeDefaultAuthorizerInput) *DescribeDefaultAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeDefaultAuthorizer", input)
	return &DescribeDefaultAuthorizerFuture{Future: future}
}

func (a *stub) DescribeDimension(ctx workflow.Context, input *iot.DescribeDimensionInput) (*iot.DescribeDimensionOutput, error) {
	var output iot.DescribeDimensionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeDimension", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDimensionAsync(ctx workflow.Context, input *iot.DescribeDimensionInput) *DescribeDimensionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeDimension", input)
	return &DescribeDimensionFuture{Future: future}
}

func (a *stub) DescribeDomainConfiguration(ctx workflow.Context, input *iot.DescribeDomainConfigurationInput) (*iot.DescribeDomainConfigurationOutput, error) {
	var output iot.DescribeDomainConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeDomainConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeDomainConfigurationAsync(ctx workflow.Context, input *iot.DescribeDomainConfigurationInput) *DescribeDomainConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeDomainConfiguration", input)
	return &DescribeDomainConfigurationFuture{Future: future}
}

func (a *stub) DescribeEndpoint(ctx workflow.Context, input *iot.DescribeEndpointInput) (*iot.DescribeEndpointOutput, error) {
	var output iot.DescribeEndpointOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeEndpoint", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEndpointAsync(ctx workflow.Context, input *iot.DescribeEndpointInput) *DescribeEndpointFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeEndpoint", input)
	return &DescribeEndpointFuture{Future: future}
}

func (a *stub) DescribeEventConfigurations(ctx workflow.Context, input *iot.DescribeEventConfigurationsInput) (*iot.DescribeEventConfigurationsOutput, error) {
	var output iot.DescribeEventConfigurationsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeEventConfigurations", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeEventConfigurationsAsync(ctx workflow.Context, input *iot.DescribeEventConfigurationsInput) *DescribeEventConfigurationsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeEventConfigurations", input)
	return &DescribeEventConfigurationsFuture{Future: future}
}

func (a *stub) DescribeIndex(ctx workflow.Context, input *iot.DescribeIndexInput) (*iot.DescribeIndexOutput, error) {
	var output iot.DescribeIndexOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeIndex", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeIndexAsync(ctx workflow.Context, input *iot.DescribeIndexInput) *DescribeIndexFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeIndex", input)
	return &DescribeIndexFuture{Future: future}
}

func (a *stub) DescribeJob(ctx workflow.Context, input *iot.DescribeJobInput) (*iot.DescribeJobOutput, error) {
	var output iot.DescribeJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeJobAsync(ctx workflow.Context, input *iot.DescribeJobInput) *DescribeJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeJob", input)
	return &DescribeJobFuture{Future: future}
}

func (a *stub) DescribeJobExecution(ctx workflow.Context, input *iot.DescribeJobExecutionInput) (*iot.DescribeJobExecutionOutput, error) {
	var output iot.DescribeJobExecutionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeJobExecution", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeJobExecutionAsync(ctx workflow.Context, input *iot.DescribeJobExecutionInput) *DescribeJobExecutionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeJobExecution", input)
	return &DescribeJobExecutionFuture{Future: future}
}

func (a *stub) DescribeMitigationAction(ctx workflow.Context, input *iot.DescribeMitigationActionInput) (*iot.DescribeMitigationActionOutput, error) {
	var output iot.DescribeMitigationActionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeMitigationAction", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeMitigationActionAsync(ctx workflow.Context, input *iot.DescribeMitigationActionInput) *DescribeMitigationActionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeMitigationAction", input)
	return &DescribeMitigationActionFuture{Future: future}
}

func (a *stub) DescribeProvisioningTemplate(ctx workflow.Context, input *iot.DescribeProvisioningTemplateInput) (*iot.DescribeProvisioningTemplateOutput, error) {
	var output iot.DescribeProvisioningTemplateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeProvisioningTemplate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeProvisioningTemplateAsync(ctx workflow.Context, input *iot.DescribeProvisioningTemplateInput) *DescribeProvisioningTemplateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeProvisioningTemplate", input)
	return &DescribeProvisioningTemplateFuture{Future: future}
}

func (a *stub) DescribeProvisioningTemplateVersion(ctx workflow.Context, input *iot.DescribeProvisioningTemplateVersionInput) (*iot.DescribeProvisioningTemplateVersionOutput, error) {
	var output iot.DescribeProvisioningTemplateVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeProvisioningTemplateVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeProvisioningTemplateVersionAsync(ctx workflow.Context, input *iot.DescribeProvisioningTemplateVersionInput) *DescribeProvisioningTemplateVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeProvisioningTemplateVersion", input)
	return &DescribeProvisioningTemplateVersionFuture{Future: future}
}

func (a *stub) DescribeRoleAlias(ctx workflow.Context, input *iot.DescribeRoleAliasInput) (*iot.DescribeRoleAliasOutput, error) {
	var output iot.DescribeRoleAliasOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeRoleAlias", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeRoleAliasAsync(ctx workflow.Context, input *iot.DescribeRoleAliasInput) *DescribeRoleAliasFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeRoleAlias", input)
	return &DescribeRoleAliasFuture{Future: future}
}

func (a *stub) DescribeScheduledAudit(ctx workflow.Context, input *iot.DescribeScheduledAuditInput) (*iot.DescribeScheduledAuditOutput, error) {
	var output iot.DescribeScheduledAuditOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeScheduledAudit", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeScheduledAuditAsync(ctx workflow.Context, input *iot.DescribeScheduledAuditInput) *DescribeScheduledAuditFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeScheduledAudit", input)
	return &DescribeScheduledAuditFuture{Future: future}
}

func (a *stub) DescribeSecurityProfile(ctx workflow.Context, input *iot.DescribeSecurityProfileInput) (*iot.DescribeSecurityProfileOutput, error) {
	var output iot.DescribeSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeSecurityProfileAsync(ctx workflow.Context, input *iot.DescribeSecurityProfileInput) *DescribeSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeSecurityProfile", input)
	return &DescribeSecurityProfileFuture{Future: future}
}

func (a *stub) DescribeStream(ctx workflow.Context, input *iot.DescribeStreamInput) (*iot.DescribeStreamOutput, error) {
	var output iot.DescribeStreamOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeStream", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeStreamAsync(ctx workflow.Context, input *iot.DescribeStreamInput) *DescribeStreamFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeStream", input)
	return &DescribeStreamFuture{Future: future}
}

func (a *stub) DescribeThing(ctx workflow.Context, input *iot.DescribeThingInput) (*iot.DescribeThingOutput, error) {
	var output iot.DescribeThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeThingAsync(ctx workflow.Context, input *iot.DescribeThingInput) *DescribeThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThing", input)
	return &DescribeThingFuture{Future: future}
}

func (a *stub) DescribeThingGroup(ctx workflow.Context, input *iot.DescribeThingGroupInput) (*iot.DescribeThingGroupOutput, error) {
	var output iot.DescribeThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeThingGroupAsync(ctx workflow.Context, input *iot.DescribeThingGroupInput) *DescribeThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThingGroup", input)
	return &DescribeThingGroupFuture{Future: future}
}

func (a *stub) DescribeThingRegistrationTask(ctx workflow.Context, input *iot.DescribeThingRegistrationTaskInput) (*iot.DescribeThingRegistrationTaskOutput, error) {
	var output iot.DescribeThingRegistrationTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThingRegistrationTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeThingRegistrationTaskAsync(ctx workflow.Context, input *iot.DescribeThingRegistrationTaskInput) *DescribeThingRegistrationTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThingRegistrationTask", input)
	return &DescribeThingRegistrationTaskFuture{Future: future}
}

func (a *stub) DescribeThingType(ctx workflow.Context, input *iot.DescribeThingTypeInput) (*iot.DescribeThingTypeOutput, error) {
	var output iot.DescribeThingTypeOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThingType", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DescribeThingTypeAsync(ctx workflow.Context, input *iot.DescribeThingTypeInput) *DescribeThingTypeFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DescribeThingType", input)
	return &DescribeThingTypeFuture{Future: future}
}

func (a *stub) DetachPolicy(ctx workflow.Context, input *iot.DetachPolicyInput) (*iot.DetachPolicyOutput, error) {
	var output iot.DetachPolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DetachPolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DetachPolicyAsync(ctx workflow.Context, input *iot.DetachPolicyInput) *DetachPolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DetachPolicy", input)
	return &DetachPolicyFuture{Future: future}
}

func (a *stub) DetachPrincipalPolicy(ctx workflow.Context, input *iot.DetachPrincipalPolicyInput) (*iot.DetachPrincipalPolicyOutput, error) {
	var output iot.DetachPrincipalPolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DetachPrincipalPolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DetachPrincipalPolicyAsync(ctx workflow.Context, input *iot.DetachPrincipalPolicyInput) *DetachPrincipalPolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DetachPrincipalPolicy", input)
	return &DetachPrincipalPolicyFuture{Future: future}
}

func (a *stub) DetachSecurityProfile(ctx workflow.Context, input *iot.DetachSecurityProfileInput) (*iot.DetachSecurityProfileOutput, error) {
	var output iot.DetachSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DetachSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DetachSecurityProfileAsync(ctx workflow.Context, input *iot.DetachSecurityProfileInput) *DetachSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DetachSecurityProfile", input)
	return &DetachSecurityProfileFuture{Future: future}
}

func (a *stub) DetachThingPrincipal(ctx workflow.Context, input *iot.DetachThingPrincipalInput) (*iot.DetachThingPrincipalOutput, error) {
	var output iot.DetachThingPrincipalOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DetachThingPrincipal", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DetachThingPrincipalAsync(ctx workflow.Context, input *iot.DetachThingPrincipalInput) *DetachThingPrincipalFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DetachThingPrincipal", input)
	return &DetachThingPrincipalFuture{Future: future}
}

func (a *stub) DisableTopicRule(ctx workflow.Context, input *iot.DisableTopicRuleInput) (*iot.DisableTopicRuleOutput, error) {
	var output iot.DisableTopicRuleOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.DisableTopicRule", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) DisableTopicRuleAsync(ctx workflow.Context, input *iot.DisableTopicRuleInput) *DisableTopicRuleFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.DisableTopicRule", input)
	return &DisableTopicRuleFuture{Future: future}
}

func (a *stub) EnableTopicRule(ctx workflow.Context, input *iot.EnableTopicRuleInput) (*iot.EnableTopicRuleOutput, error) {
	var output iot.EnableTopicRuleOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.EnableTopicRule", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) EnableTopicRuleAsync(ctx workflow.Context, input *iot.EnableTopicRuleInput) *EnableTopicRuleFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.EnableTopicRule", input)
	return &EnableTopicRuleFuture{Future: future}
}

func (a *stub) GetCardinality(ctx workflow.Context, input *iot.GetCardinalityInput) (*iot.GetCardinalityOutput, error) {
	var output iot.GetCardinalityOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetCardinality", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetCardinalityAsync(ctx workflow.Context, input *iot.GetCardinalityInput) *GetCardinalityFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetCardinality", input)
	return &GetCardinalityFuture{Future: future}
}

func (a *stub) GetEffectivePolicies(ctx workflow.Context, input *iot.GetEffectivePoliciesInput) (*iot.GetEffectivePoliciesOutput, error) {
	var output iot.GetEffectivePoliciesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetEffectivePolicies", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetEffectivePoliciesAsync(ctx workflow.Context, input *iot.GetEffectivePoliciesInput) *GetEffectivePoliciesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetEffectivePolicies", input)
	return &GetEffectivePoliciesFuture{Future: future}
}

func (a *stub) GetIndexingConfiguration(ctx workflow.Context, input *iot.GetIndexingConfigurationInput) (*iot.GetIndexingConfigurationOutput, error) {
	var output iot.GetIndexingConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetIndexingConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetIndexingConfigurationAsync(ctx workflow.Context, input *iot.GetIndexingConfigurationInput) *GetIndexingConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetIndexingConfiguration", input)
	return &GetIndexingConfigurationFuture{Future: future}
}

func (a *stub) GetJobDocument(ctx workflow.Context, input *iot.GetJobDocumentInput) (*iot.GetJobDocumentOutput, error) {
	var output iot.GetJobDocumentOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetJobDocument", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetJobDocumentAsync(ctx workflow.Context, input *iot.GetJobDocumentInput) *GetJobDocumentFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetJobDocument", input)
	return &GetJobDocumentFuture{Future: future}
}

func (a *stub) GetLoggingOptions(ctx workflow.Context, input *iot.GetLoggingOptionsInput) (*iot.GetLoggingOptionsOutput, error) {
	var output iot.GetLoggingOptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetLoggingOptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetLoggingOptionsAsync(ctx workflow.Context, input *iot.GetLoggingOptionsInput) *GetLoggingOptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetLoggingOptions", input)
	return &GetLoggingOptionsFuture{Future: future}
}

func (a *stub) GetOTAUpdate(ctx workflow.Context, input *iot.GetOTAUpdateInput) (*iot.GetOTAUpdateOutput, error) {
	var output iot.GetOTAUpdateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetOTAUpdate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetOTAUpdateAsync(ctx workflow.Context, input *iot.GetOTAUpdateInput) *GetOTAUpdateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetOTAUpdate", input)
	return &GetOTAUpdateFuture{Future: future}
}

func (a *stub) GetPercentiles(ctx workflow.Context, input *iot.GetPercentilesInput) (*iot.GetPercentilesOutput, error) {
	var output iot.GetPercentilesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetPercentiles", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetPercentilesAsync(ctx workflow.Context, input *iot.GetPercentilesInput) *GetPercentilesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetPercentiles", input)
	return &GetPercentilesFuture{Future: future}
}

func (a *stub) GetPolicy(ctx workflow.Context, input *iot.GetPolicyInput) (*iot.GetPolicyOutput, error) {
	var output iot.GetPolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetPolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetPolicyAsync(ctx workflow.Context, input *iot.GetPolicyInput) *GetPolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetPolicy", input)
	return &GetPolicyFuture{Future: future}
}

func (a *stub) GetPolicyVersion(ctx workflow.Context, input *iot.GetPolicyVersionInput) (*iot.GetPolicyVersionOutput, error) {
	var output iot.GetPolicyVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetPolicyVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetPolicyVersionAsync(ctx workflow.Context, input *iot.GetPolicyVersionInput) *GetPolicyVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetPolicyVersion", input)
	return &GetPolicyVersionFuture{Future: future}
}

func (a *stub) GetRegistrationCode(ctx workflow.Context, input *iot.GetRegistrationCodeInput) (*iot.GetRegistrationCodeOutput, error) {
	var output iot.GetRegistrationCodeOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetRegistrationCode", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetRegistrationCodeAsync(ctx workflow.Context, input *iot.GetRegistrationCodeInput) *GetRegistrationCodeFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetRegistrationCode", input)
	return &GetRegistrationCodeFuture{Future: future}
}

func (a *stub) GetStatistics(ctx workflow.Context, input *iot.GetStatisticsInput) (*iot.GetStatisticsOutput, error) {
	var output iot.GetStatisticsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetStatistics", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetStatisticsAsync(ctx workflow.Context, input *iot.GetStatisticsInput) *GetStatisticsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetStatistics", input)
	return &GetStatisticsFuture{Future: future}
}

func (a *stub) GetTopicRule(ctx workflow.Context, input *iot.GetTopicRuleInput) (*iot.GetTopicRuleOutput, error) {
	var output iot.GetTopicRuleOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetTopicRule", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetTopicRuleAsync(ctx workflow.Context, input *iot.GetTopicRuleInput) *GetTopicRuleFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetTopicRule", input)
	return &GetTopicRuleFuture{Future: future}
}

func (a *stub) GetTopicRuleDestination(ctx workflow.Context, input *iot.GetTopicRuleDestinationInput) (*iot.GetTopicRuleDestinationOutput, error) {
	var output iot.GetTopicRuleDestinationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetTopicRuleDestination", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetTopicRuleDestinationAsync(ctx workflow.Context, input *iot.GetTopicRuleDestinationInput) *GetTopicRuleDestinationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetTopicRuleDestination", input)
	return &GetTopicRuleDestinationFuture{Future: future}
}

func (a *stub) GetV2LoggingOptions(ctx workflow.Context, input *iot.GetV2LoggingOptionsInput) (*iot.GetV2LoggingOptionsOutput, error) {
	var output iot.GetV2LoggingOptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.GetV2LoggingOptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) GetV2LoggingOptionsAsync(ctx workflow.Context, input *iot.GetV2LoggingOptionsInput) *GetV2LoggingOptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.GetV2LoggingOptions", input)
	return &GetV2LoggingOptionsFuture{Future: future}
}

func (a *stub) ListActiveViolations(ctx workflow.Context, input *iot.ListActiveViolationsInput) (*iot.ListActiveViolationsOutput, error) {
	var output iot.ListActiveViolationsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListActiveViolations", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListActiveViolationsAsync(ctx workflow.Context, input *iot.ListActiveViolationsInput) *ListActiveViolationsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListActiveViolations", input)
	return &ListActiveViolationsFuture{Future: future}
}

func (a *stub) ListAttachedPolicies(ctx workflow.Context, input *iot.ListAttachedPoliciesInput) (*iot.ListAttachedPoliciesOutput, error) {
	var output iot.ListAttachedPoliciesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAttachedPolicies", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAttachedPoliciesAsync(ctx workflow.Context, input *iot.ListAttachedPoliciesInput) *ListAttachedPoliciesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAttachedPolicies", input)
	return &ListAttachedPoliciesFuture{Future: future}
}

func (a *stub) ListAuditFindings(ctx workflow.Context, input *iot.ListAuditFindingsInput) (*iot.ListAuditFindingsOutput, error) {
	var output iot.ListAuditFindingsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditFindings", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAuditFindingsAsync(ctx workflow.Context, input *iot.ListAuditFindingsInput) *ListAuditFindingsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditFindings", input)
	return &ListAuditFindingsFuture{Future: future}
}

func (a *stub) ListAuditMitigationActionsExecutions(ctx workflow.Context, input *iot.ListAuditMitigationActionsExecutionsInput) (*iot.ListAuditMitigationActionsExecutionsOutput, error) {
	var output iot.ListAuditMitigationActionsExecutionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditMitigationActionsExecutions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAuditMitigationActionsExecutionsAsync(ctx workflow.Context, input *iot.ListAuditMitigationActionsExecutionsInput) *ListAuditMitigationActionsExecutionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditMitigationActionsExecutions", input)
	return &ListAuditMitigationActionsExecutionsFuture{Future: future}
}

func (a *stub) ListAuditMitigationActionsTasks(ctx workflow.Context, input *iot.ListAuditMitigationActionsTasksInput) (*iot.ListAuditMitigationActionsTasksOutput, error) {
	var output iot.ListAuditMitigationActionsTasksOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditMitigationActionsTasks", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAuditMitigationActionsTasksAsync(ctx workflow.Context, input *iot.ListAuditMitigationActionsTasksInput) *ListAuditMitigationActionsTasksFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditMitigationActionsTasks", input)
	return &ListAuditMitigationActionsTasksFuture{Future: future}
}

func (a *stub) ListAuditSuppressions(ctx workflow.Context, input *iot.ListAuditSuppressionsInput) (*iot.ListAuditSuppressionsOutput, error) {
	var output iot.ListAuditSuppressionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditSuppressions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAuditSuppressionsAsync(ctx workflow.Context, input *iot.ListAuditSuppressionsInput) *ListAuditSuppressionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditSuppressions", input)
	return &ListAuditSuppressionsFuture{Future: future}
}

func (a *stub) ListAuditTasks(ctx workflow.Context, input *iot.ListAuditTasksInput) (*iot.ListAuditTasksOutput, error) {
	var output iot.ListAuditTasksOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditTasks", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAuditTasksAsync(ctx workflow.Context, input *iot.ListAuditTasksInput) *ListAuditTasksFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAuditTasks", input)
	return &ListAuditTasksFuture{Future: future}
}

func (a *stub) ListAuthorizers(ctx workflow.Context, input *iot.ListAuthorizersInput) (*iot.ListAuthorizersOutput, error) {
	var output iot.ListAuthorizersOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListAuthorizers", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListAuthorizersAsync(ctx workflow.Context, input *iot.ListAuthorizersInput) *ListAuthorizersFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListAuthorizers", input)
	return &ListAuthorizersFuture{Future: future}
}

func (a *stub) ListBillingGroups(ctx workflow.Context, input *iot.ListBillingGroupsInput) (*iot.ListBillingGroupsOutput, error) {
	var output iot.ListBillingGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListBillingGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListBillingGroupsAsync(ctx workflow.Context, input *iot.ListBillingGroupsInput) *ListBillingGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListBillingGroups", input)
	return &ListBillingGroupsFuture{Future: future}
}

func (a *stub) ListCACertificates(ctx workflow.Context, input *iot.ListCACertificatesInput) (*iot.ListCACertificatesOutput, error) {
	var output iot.ListCACertificatesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListCACertificates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListCACertificatesAsync(ctx workflow.Context, input *iot.ListCACertificatesInput) *ListCACertificatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListCACertificates", input)
	return &ListCACertificatesFuture{Future: future}
}

func (a *stub) ListCertificates(ctx workflow.Context, input *iot.ListCertificatesInput) (*iot.ListCertificatesOutput, error) {
	var output iot.ListCertificatesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListCertificates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListCertificatesAsync(ctx workflow.Context, input *iot.ListCertificatesInput) *ListCertificatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListCertificates", input)
	return &ListCertificatesFuture{Future: future}
}

func (a *stub) ListCertificatesByCA(ctx workflow.Context, input *iot.ListCertificatesByCAInput) (*iot.ListCertificatesByCAOutput, error) {
	var output iot.ListCertificatesByCAOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListCertificatesByCA", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListCertificatesByCAAsync(ctx workflow.Context, input *iot.ListCertificatesByCAInput) *ListCertificatesByCAFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListCertificatesByCA", input)
	return &ListCertificatesByCAFuture{Future: future}
}

func (a *stub) ListDimensions(ctx workflow.Context, input *iot.ListDimensionsInput) (*iot.ListDimensionsOutput, error) {
	var output iot.ListDimensionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListDimensions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListDimensionsAsync(ctx workflow.Context, input *iot.ListDimensionsInput) *ListDimensionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListDimensions", input)
	return &ListDimensionsFuture{Future: future}
}

func (a *stub) ListDomainConfigurations(ctx workflow.Context, input *iot.ListDomainConfigurationsInput) (*iot.ListDomainConfigurationsOutput, error) {
	var output iot.ListDomainConfigurationsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListDomainConfigurations", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListDomainConfigurationsAsync(ctx workflow.Context, input *iot.ListDomainConfigurationsInput) *ListDomainConfigurationsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListDomainConfigurations", input)
	return &ListDomainConfigurationsFuture{Future: future}
}

func (a *stub) ListIndices(ctx workflow.Context, input *iot.ListIndicesInput) (*iot.ListIndicesOutput, error) {
	var output iot.ListIndicesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListIndices", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListIndicesAsync(ctx workflow.Context, input *iot.ListIndicesInput) *ListIndicesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListIndices", input)
	return &ListIndicesFuture{Future: future}
}

func (a *stub) ListJobExecutionsForJob(ctx workflow.Context, input *iot.ListJobExecutionsForJobInput) (*iot.ListJobExecutionsForJobOutput, error) {
	var output iot.ListJobExecutionsForJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListJobExecutionsForJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListJobExecutionsForJobAsync(ctx workflow.Context, input *iot.ListJobExecutionsForJobInput) *ListJobExecutionsForJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListJobExecutionsForJob", input)
	return &ListJobExecutionsForJobFuture{Future: future}
}

func (a *stub) ListJobExecutionsForThing(ctx workflow.Context, input *iot.ListJobExecutionsForThingInput) (*iot.ListJobExecutionsForThingOutput, error) {
	var output iot.ListJobExecutionsForThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListJobExecutionsForThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListJobExecutionsForThingAsync(ctx workflow.Context, input *iot.ListJobExecutionsForThingInput) *ListJobExecutionsForThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListJobExecutionsForThing", input)
	return &ListJobExecutionsForThingFuture{Future: future}
}

func (a *stub) ListJobs(ctx workflow.Context, input *iot.ListJobsInput) (*iot.ListJobsOutput, error) {
	var output iot.ListJobsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListJobs", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListJobsAsync(ctx workflow.Context, input *iot.ListJobsInput) *ListJobsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListJobs", input)
	return &ListJobsFuture{Future: future}
}

func (a *stub) ListMitigationActions(ctx workflow.Context, input *iot.ListMitigationActionsInput) (*iot.ListMitigationActionsOutput, error) {
	var output iot.ListMitigationActionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListMitigationActions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListMitigationActionsAsync(ctx workflow.Context, input *iot.ListMitigationActionsInput) *ListMitigationActionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListMitigationActions", input)
	return &ListMitigationActionsFuture{Future: future}
}

func (a *stub) ListOTAUpdates(ctx workflow.Context, input *iot.ListOTAUpdatesInput) (*iot.ListOTAUpdatesOutput, error) {
	var output iot.ListOTAUpdatesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListOTAUpdates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListOTAUpdatesAsync(ctx workflow.Context, input *iot.ListOTAUpdatesInput) *ListOTAUpdatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListOTAUpdates", input)
	return &ListOTAUpdatesFuture{Future: future}
}

func (a *stub) ListOutgoingCertificates(ctx workflow.Context, input *iot.ListOutgoingCertificatesInput) (*iot.ListOutgoingCertificatesOutput, error) {
	var output iot.ListOutgoingCertificatesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListOutgoingCertificates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListOutgoingCertificatesAsync(ctx workflow.Context, input *iot.ListOutgoingCertificatesInput) *ListOutgoingCertificatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListOutgoingCertificates", input)
	return &ListOutgoingCertificatesFuture{Future: future}
}

func (a *stub) ListPolicies(ctx workflow.Context, input *iot.ListPoliciesInput) (*iot.ListPoliciesOutput, error) {
	var output iot.ListPoliciesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListPolicies", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListPoliciesAsync(ctx workflow.Context, input *iot.ListPoliciesInput) *ListPoliciesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListPolicies", input)
	return &ListPoliciesFuture{Future: future}
}

func (a *stub) ListPolicyPrincipals(ctx workflow.Context, input *iot.ListPolicyPrincipalsInput) (*iot.ListPolicyPrincipalsOutput, error) {
	var output iot.ListPolicyPrincipalsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListPolicyPrincipals", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListPolicyPrincipalsAsync(ctx workflow.Context, input *iot.ListPolicyPrincipalsInput) *ListPolicyPrincipalsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListPolicyPrincipals", input)
	return &ListPolicyPrincipalsFuture{Future: future}
}

func (a *stub) ListPolicyVersions(ctx workflow.Context, input *iot.ListPolicyVersionsInput) (*iot.ListPolicyVersionsOutput, error) {
	var output iot.ListPolicyVersionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListPolicyVersions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListPolicyVersionsAsync(ctx workflow.Context, input *iot.ListPolicyVersionsInput) *ListPolicyVersionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListPolicyVersions", input)
	return &ListPolicyVersionsFuture{Future: future}
}

func (a *stub) ListPrincipalPolicies(ctx workflow.Context, input *iot.ListPrincipalPoliciesInput) (*iot.ListPrincipalPoliciesOutput, error) {
	var output iot.ListPrincipalPoliciesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListPrincipalPolicies", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListPrincipalPoliciesAsync(ctx workflow.Context, input *iot.ListPrincipalPoliciesInput) *ListPrincipalPoliciesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListPrincipalPolicies", input)
	return &ListPrincipalPoliciesFuture{Future: future}
}

func (a *stub) ListPrincipalThings(ctx workflow.Context, input *iot.ListPrincipalThingsInput) (*iot.ListPrincipalThingsOutput, error) {
	var output iot.ListPrincipalThingsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListPrincipalThings", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListPrincipalThingsAsync(ctx workflow.Context, input *iot.ListPrincipalThingsInput) *ListPrincipalThingsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListPrincipalThings", input)
	return &ListPrincipalThingsFuture{Future: future}
}

func (a *stub) ListProvisioningTemplateVersions(ctx workflow.Context, input *iot.ListProvisioningTemplateVersionsInput) (*iot.ListProvisioningTemplateVersionsOutput, error) {
	var output iot.ListProvisioningTemplateVersionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListProvisioningTemplateVersions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListProvisioningTemplateVersionsAsync(ctx workflow.Context, input *iot.ListProvisioningTemplateVersionsInput) *ListProvisioningTemplateVersionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListProvisioningTemplateVersions", input)
	return &ListProvisioningTemplateVersionsFuture{Future: future}
}

func (a *stub) ListProvisioningTemplates(ctx workflow.Context, input *iot.ListProvisioningTemplatesInput) (*iot.ListProvisioningTemplatesOutput, error) {
	var output iot.ListProvisioningTemplatesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListProvisioningTemplates", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListProvisioningTemplatesAsync(ctx workflow.Context, input *iot.ListProvisioningTemplatesInput) *ListProvisioningTemplatesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListProvisioningTemplates", input)
	return &ListProvisioningTemplatesFuture{Future: future}
}

func (a *stub) ListRoleAliases(ctx workflow.Context, input *iot.ListRoleAliasesInput) (*iot.ListRoleAliasesOutput, error) {
	var output iot.ListRoleAliasesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListRoleAliases", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListRoleAliasesAsync(ctx workflow.Context, input *iot.ListRoleAliasesInput) *ListRoleAliasesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListRoleAliases", input)
	return &ListRoleAliasesFuture{Future: future}
}

func (a *stub) ListScheduledAudits(ctx workflow.Context, input *iot.ListScheduledAuditsInput) (*iot.ListScheduledAuditsOutput, error) {
	var output iot.ListScheduledAuditsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListScheduledAudits", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListScheduledAuditsAsync(ctx workflow.Context, input *iot.ListScheduledAuditsInput) *ListScheduledAuditsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListScheduledAudits", input)
	return &ListScheduledAuditsFuture{Future: future}
}

func (a *stub) ListSecurityProfiles(ctx workflow.Context, input *iot.ListSecurityProfilesInput) (*iot.ListSecurityProfilesOutput, error) {
	var output iot.ListSecurityProfilesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListSecurityProfiles", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListSecurityProfilesAsync(ctx workflow.Context, input *iot.ListSecurityProfilesInput) *ListSecurityProfilesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListSecurityProfiles", input)
	return &ListSecurityProfilesFuture{Future: future}
}

func (a *stub) ListSecurityProfilesForTarget(ctx workflow.Context, input *iot.ListSecurityProfilesForTargetInput) (*iot.ListSecurityProfilesForTargetOutput, error) {
	var output iot.ListSecurityProfilesForTargetOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListSecurityProfilesForTarget", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListSecurityProfilesForTargetAsync(ctx workflow.Context, input *iot.ListSecurityProfilesForTargetInput) *ListSecurityProfilesForTargetFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListSecurityProfilesForTarget", input)
	return &ListSecurityProfilesForTargetFuture{Future: future}
}

func (a *stub) ListStreams(ctx workflow.Context, input *iot.ListStreamsInput) (*iot.ListStreamsOutput, error) {
	var output iot.ListStreamsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListStreams", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListStreamsAsync(ctx workflow.Context, input *iot.ListStreamsInput) *ListStreamsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListStreams", input)
	return &ListStreamsFuture{Future: future}
}

func (a *stub) ListTagsForResource(ctx workflow.Context, input *iot.ListTagsForResourceInput) (*iot.ListTagsForResourceOutput, error) {
	var output iot.ListTagsForResourceOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListTagsForResource", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListTagsForResourceAsync(ctx workflow.Context, input *iot.ListTagsForResourceInput) *ListTagsForResourceFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListTagsForResource", input)
	return &ListTagsForResourceFuture{Future: future}
}

func (a *stub) ListTargetsForPolicy(ctx workflow.Context, input *iot.ListTargetsForPolicyInput) (*iot.ListTargetsForPolicyOutput, error) {
	var output iot.ListTargetsForPolicyOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListTargetsForPolicy", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListTargetsForPolicyAsync(ctx workflow.Context, input *iot.ListTargetsForPolicyInput) *ListTargetsForPolicyFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListTargetsForPolicy", input)
	return &ListTargetsForPolicyFuture{Future: future}
}

func (a *stub) ListTargetsForSecurityProfile(ctx workflow.Context, input *iot.ListTargetsForSecurityProfileInput) (*iot.ListTargetsForSecurityProfileOutput, error) {
	var output iot.ListTargetsForSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListTargetsForSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListTargetsForSecurityProfileAsync(ctx workflow.Context, input *iot.ListTargetsForSecurityProfileInput) *ListTargetsForSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListTargetsForSecurityProfile", input)
	return &ListTargetsForSecurityProfileFuture{Future: future}
}

func (a *stub) ListThingGroups(ctx workflow.Context, input *iot.ListThingGroupsInput) (*iot.ListThingGroupsOutput, error) {
	var output iot.ListThingGroupsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingGroups", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingGroupsAsync(ctx workflow.Context, input *iot.ListThingGroupsInput) *ListThingGroupsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingGroups", input)
	return &ListThingGroupsFuture{Future: future}
}

func (a *stub) ListThingGroupsForThing(ctx workflow.Context, input *iot.ListThingGroupsForThingInput) (*iot.ListThingGroupsForThingOutput, error) {
	var output iot.ListThingGroupsForThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingGroupsForThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingGroupsForThingAsync(ctx workflow.Context, input *iot.ListThingGroupsForThingInput) *ListThingGroupsForThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingGroupsForThing", input)
	return &ListThingGroupsForThingFuture{Future: future}
}

func (a *stub) ListThingPrincipals(ctx workflow.Context, input *iot.ListThingPrincipalsInput) (*iot.ListThingPrincipalsOutput, error) {
	var output iot.ListThingPrincipalsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingPrincipals", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingPrincipalsAsync(ctx workflow.Context, input *iot.ListThingPrincipalsInput) *ListThingPrincipalsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingPrincipals", input)
	return &ListThingPrincipalsFuture{Future: future}
}

func (a *stub) ListThingRegistrationTaskReports(ctx workflow.Context, input *iot.ListThingRegistrationTaskReportsInput) (*iot.ListThingRegistrationTaskReportsOutput, error) {
	var output iot.ListThingRegistrationTaskReportsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingRegistrationTaskReports", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingRegistrationTaskReportsAsync(ctx workflow.Context, input *iot.ListThingRegistrationTaskReportsInput) *ListThingRegistrationTaskReportsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingRegistrationTaskReports", input)
	return &ListThingRegistrationTaskReportsFuture{Future: future}
}

func (a *stub) ListThingRegistrationTasks(ctx workflow.Context, input *iot.ListThingRegistrationTasksInput) (*iot.ListThingRegistrationTasksOutput, error) {
	var output iot.ListThingRegistrationTasksOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingRegistrationTasks", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingRegistrationTasksAsync(ctx workflow.Context, input *iot.ListThingRegistrationTasksInput) *ListThingRegistrationTasksFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingRegistrationTasks", input)
	return &ListThingRegistrationTasksFuture{Future: future}
}

func (a *stub) ListThingTypes(ctx workflow.Context, input *iot.ListThingTypesInput) (*iot.ListThingTypesOutput, error) {
	var output iot.ListThingTypesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingTypes", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingTypesAsync(ctx workflow.Context, input *iot.ListThingTypesInput) *ListThingTypesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingTypes", input)
	return &ListThingTypesFuture{Future: future}
}

func (a *stub) ListThings(ctx workflow.Context, input *iot.ListThingsInput) (*iot.ListThingsOutput, error) {
	var output iot.ListThingsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThings", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingsAsync(ctx workflow.Context, input *iot.ListThingsInput) *ListThingsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThings", input)
	return &ListThingsFuture{Future: future}
}

func (a *stub) ListThingsInBillingGroup(ctx workflow.Context, input *iot.ListThingsInBillingGroupInput) (*iot.ListThingsInBillingGroupOutput, error) {
	var output iot.ListThingsInBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingsInBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingsInBillingGroupAsync(ctx workflow.Context, input *iot.ListThingsInBillingGroupInput) *ListThingsInBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingsInBillingGroup", input)
	return &ListThingsInBillingGroupFuture{Future: future}
}

func (a *stub) ListThingsInThingGroup(ctx workflow.Context, input *iot.ListThingsInThingGroupInput) (*iot.ListThingsInThingGroupOutput, error) {
	var output iot.ListThingsInThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListThingsInThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListThingsInThingGroupAsync(ctx workflow.Context, input *iot.ListThingsInThingGroupInput) *ListThingsInThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListThingsInThingGroup", input)
	return &ListThingsInThingGroupFuture{Future: future}
}

func (a *stub) ListTopicRuleDestinations(ctx workflow.Context, input *iot.ListTopicRuleDestinationsInput) (*iot.ListTopicRuleDestinationsOutput, error) {
	var output iot.ListTopicRuleDestinationsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListTopicRuleDestinations", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListTopicRuleDestinationsAsync(ctx workflow.Context, input *iot.ListTopicRuleDestinationsInput) *ListTopicRuleDestinationsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListTopicRuleDestinations", input)
	return &ListTopicRuleDestinationsFuture{Future: future}
}

func (a *stub) ListTopicRules(ctx workflow.Context, input *iot.ListTopicRulesInput) (*iot.ListTopicRulesOutput, error) {
	var output iot.ListTopicRulesOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListTopicRules", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListTopicRulesAsync(ctx workflow.Context, input *iot.ListTopicRulesInput) *ListTopicRulesFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListTopicRules", input)
	return &ListTopicRulesFuture{Future: future}
}

func (a *stub) ListV2LoggingLevels(ctx workflow.Context, input *iot.ListV2LoggingLevelsInput) (*iot.ListV2LoggingLevelsOutput, error) {
	var output iot.ListV2LoggingLevelsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListV2LoggingLevels", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListV2LoggingLevelsAsync(ctx workflow.Context, input *iot.ListV2LoggingLevelsInput) *ListV2LoggingLevelsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListV2LoggingLevels", input)
	return &ListV2LoggingLevelsFuture{Future: future}
}

func (a *stub) ListViolationEvents(ctx workflow.Context, input *iot.ListViolationEventsInput) (*iot.ListViolationEventsOutput, error) {
	var output iot.ListViolationEventsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ListViolationEvents", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ListViolationEventsAsync(ctx workflow.Context, input *iot.ListViolationEventsInput) *ListViolationEventsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ListViolationEvents", input)
	return &ListViolationEventsFuture{Future: future}
}

func (a *stub) RegisterCACertificate(ctx workflow.Context, input *iot.RegisterCACertificateInput) (*iot.RegisterCACertificateOutput, error) {
	var output iot.RegisterCACertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RegisterCACertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RegisterCACertificateAsync(ctx workflow.Context, input *iot.RegisterCACertificateInput) *RegisterCACertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RegisterCACertificate", input)
	return &RegisterCACertificateFuture{Future: future}
}

func (a *stub) RegisterCertificate(ctx workflow.Context, input *iot.RegisterCertificateInput) (*iot.RegisterCertificateOutput, error) {
	var output iot.RegisterCertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RegisterCertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RegisterCertificateAsync(ctx workflow.Context, input *iot.RegisterCertificateInput) *RegisterCertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RegisterCertificate", input)
	return &RegisterCertificateFuture{Future: future}
}

func (a *stub) RegisterCertificateWithoutCA(ctx workflow.Context, input *iot.RegisterCertificateWithoutCAInput) (*iot.RegisterCertificateWithoutCAOutput, error) {
	var output iot.RegisterCertificateWithoutCAOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RegisterCertificateWithoutCA", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RegisterCertificateWithoutCAAsync(ctx workflow.Context, input *iot.RegisterCertificateWithoutCAInput) *RegisterCertificateWithoutCAFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RegisterCertificateWithoutCA", input)
	return &RegisterCertificateWithoutCAFuture{Future: future}
}

func (a *stub) RegisterThing(ctx workflow.Context, input *iot.RegisterThingInput) (*iot.RegisterThingOutput, error) {
	var output iot.RegisterThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RegisterThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RegisterThingAsync(ctx workflow.Context, input *iot.RegisterThingInput) *RegisterThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RegisterThing", input)
	return &RegisterThingFuture{Future: future}
}

func (a *stub) RejectCertificateTransfer(ctx workflow.Context, input *iot.RejectCertificateTransferInput) (*iot.RejectCertificateTransferOutput, error) {
	var output iot.RejectCertificateTransferOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RejectCertificateTransfer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RejectCertificateTransferAsync(ctx workflow.Context, input *iot.RejectCertificateTransferInput) *RejectCertificateTransferFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RejectCertificateTransfer", input)
	return &RejectCertificateTransferFuture{Future: future}
}

func (a *stub) RemoveThingFromBillingGroup(ctx workflow.Context, input *iot.RemoveThingFromBillingGroupInput) (*iot.RemoveThingFromBillingGroupOutput, error) {
	var output iot.RemoveThingFromBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RemoveThingFromBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveThingFromBillingGroupAsync(ctx workflow.Context, input *iot.RemoveThingFromBillingGroupInput) *RemoveThingFromBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RemoveThingFromBillingGroup", input)
	return &RemoveThingFromBillingGroupFuture{Future: future}
}

func (a *stub) RemoveThingFromThingGroup(ctx workflow.Context, input *iot.RemoveThingFromThingGroupInput) (*iot.RemoveThingFromThingGroupOutput, error) {
	var output iot.RemoveThingFromThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.RemoveThingFromThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) RemoveThingFromThingGroupAsync(ctx workflow.Context, input *iot.RemoveThingFromThingGroupInput) *RemoveThingFromThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.RemoveThingFromThingGroup", input)
	return &RemoveThingFromThingGroupFuture{Future: future}
}

func (a *stub) ReplaceTopicRule(ctx workflow.Context, input *iot.ReplaceTopicRuleInput) (*iot.ReplaceTopicRuleOutput, error) {
	var output iot.ReplaceTopicRuleOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ReplaceTopicRule", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ReplaceTopicRuleAsync(ctx workflow.Context, input *iot.ReplaceTopicRuleInput) *ReplaceTopicRuleFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ReplaceTopicRule", input)
	return &ReplaceTopicRuleFuture{Future: future}
}

func (a *stub) SearchIndex(ctx workflow.Context, input *iot.SearchIndexInput) (*iot.SearchIndexOutput, error) {
	var output iot.SearchIndexOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.SearchIndex", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) SearchIndexAsync(ctx workflow.Context, input *iot.SearchIndexInput) *SearchIndexFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.SearchIndex", input)
	return &SearchIndexFuture{Future: future}
}

func (a *stub) SetDefaultAuthorizer(ctx workflow.Context, input *iot.SetDefaultAuthorizerInput) (*iot.SetDefaultAuthorizerOutput, error) {
	var output iot.SetDefaultAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.SetDefaultAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) SetDefaultAuthorizerAsync(ctx workflow.Context, input *iot.SetDefaultAuthorizerInput) *SetDefaultAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.SetDefaultAuthorizer", input)
	return &SetDefaultAuthorizerFuture{Future: future}
}

func (a *stub) SetDefaultPolicyVersion(ctx workflow.Context, input *iot.SetDefaultPolicyVersionInput) (*iot.SetDefaultPolicyVersionOutput, error) {
	var output iot.SetDefaultPolicyVersionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.SetDefaultPolicyVersion", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) SetDefaultPolicyVersionAsync(ctx workflow.Context, input *iot.SetDefaultPolicyVersionInput) *SetDefaultPolicyVersionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.SetDefaultPolicyVersion", input)
	return &SetDefaultPolicyVersionFuture{Future: future}
}

func (a *stub) SetLoggingOptions(ctx workflow.Context, input *iot.SetLoggingOptionsInput) (*iot.SetLoggingOptionsOutput, error) {
	var output iot.SetLoggingOptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.SetLoggingOptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) SetLoggingOptionsAsync(ctx workflow.Context, input *iot.SetLoggingOptionsInput) *SetLoggingOptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.SetLoggingOptions", input)
	return &SetLoggingOptionsFuture{Future: future}
}

func (a *stub) SetV2LoggingLevel(ctx workflow.Context, input *iot.SetV2LoggingLevelInput) (*iot.SetV2LoggingLevelOutput, error) {
	var output iot.SetV2LoggingLevelOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.SetV2LoggingLevel", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) SetV2LoggingLevelAsync(ctx workflow.Context, input *iot.SetV2LoggingLevelInput) *SetV2LoggingLevelFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.SetV2LoggingLevel", input)
	return &SetV2LoggingLevelFuture{Future: future}
}

func (a *stub) SetV2LoggingOptions(ctx workflow.Context, input *iot.SetV2LoggingOptionsInput) (*iot.SetV2LoggingOptionsOutput, error) {
	var output iot.SetV2LoggingOptionsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.SetV2LoggingOptions", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) SetV2LoggingOptionsAsync(ctx workflow.Context, input *iot.SetV2LoggingOptionsInput) *SetV2LoggingOptionsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.SetV2LoggingOptions", input)
	return &SetV2LoggingOptionsFuture{Future: future}
}

func (a *stub) StartAuditMitigationActionsTask(ctx workflow.Context, input *iot.StartAuditMitigationActionsTaskInput) (*iot.StartAuditMitigationActionsTaskOutput, error) {
	var output iot.StartAuditMitigationActionsTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.StartAuditMitigationActionsTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartAuditMitigationActionsTaskAsync(ctx workflow.Context, input *iot.StartAuditMitigationActionsTaskInput) *StartAuditMitigationActionsTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.StartAuditMitigationActionsTask", input)
	return &StartAuditMitigationActionsTaskFuture{Future: future}
}

func (a *stub) StartOnDemandAuditTask(ctx workflow.Context, input *iot.StartOnDemandAuditTaskInput) (*iot.StartOnDemandAuditTaskOutput, error) {
	var output iot.StartOnDemandAuditTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.StartOnDemandAuditTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartOnDemandAuditTaskAsync(ctx workflow.Context, input *iot.StartOnDemandAuditTaskInput) *StartOnDemandAuditTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.StartOnDemandAuditTask", input)
	return &StartOnDemandAuditTaskFuture{Future: future}
}

func (a *stub) StartThingRegistrationTask(ctx workflow.Context, input *iot.StartThingRegistrationTaskInput) (*iot.StartThingRegistrationTaskOutput, error) {
	var output iot.StartThingRegistrationTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.StartThingRegistrationTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StartThingRegistrationTaskAsync(ctx workflow.Context, input *iot.StartThingRegistrationTaskInput) *StartThingRegistrationTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.StartThingRegistrationTask", input)
	return &StartThingRegistrationTaskFuture{Future: future}
}

func (a *stub) StopThingRegistrationTask(ctx workflow.Context, input *iot.StopThingRegistrationTaskInput) (*iot.StopThingRegistrationTaskOutput, error) {
	var output iot.StopThingRegistrationTaskOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.StopThingRegistrationTask", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) StopThingRegistrationTaskAsync(ctx workflow.Context, input *iot.StopThingRegistrationTaskInput) *StopThingRegistrationTaskFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.StopThingRegistrationTask", input)
	return &StopThingRegistrationTaskFuture{Future: future}
}

func (a *stub) TagResource(ctx workflow.Context, input *iot.TagResourceInput) (*iot.TagResourceOutput, error) {
	var output iot.TagResourceOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.TagResource", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) TagResourceAsync(ctx workflow.Context, input *iot.TagResourceInput) *TagResourceFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.TagResource", input)
	return &TagResourceFuture{Future: future}
}

func (a *stub) TestAuthorization(ctx workflow.Context, input *iot.TestAuthorizationInput) (*iot.TestAuthorizationOutput, error) {
	var output iot.TestAuthorizationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.TestAuthorization", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) TestAuthorizationAsync(ctx workflow.Context, input *iot.TestAuthorizationInput) *TestAuthorizationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.TestAuthorization", input)
	return &TestAuthorizationFuture{Future: future}
}

func (a *stub) TestInvokeAuthorizer(ctx workflow.Context, input *iot.TestInvokeAuthorizerInput) (*iot.TestInvokeAuthorizerOutput, error) {
	var output iot.TestInvokeAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.TestInvokeAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) TestInvokeAuthorizerAsync(ctx workflow.Context, input *iot.TestInvokeAuthorizerInput) *TestInvokeAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.TestInvokeAuthorizer", input)
	return &TestInvokeAuthorizerFuture{Future: future}
}

func (a *stub) TransferCertificate(ctx workflow.Context, input *iot.TransferCertificateInput) (*iot.TransferCertificateOutput, error) {
	var output iot.TransferCertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.TransferCertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) TransferCertificateAsync(ctx workflow.Context, input *iot.TransferCertificateInput) *TransferCertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.TransferCertificate", input)
	return &TransferCertificateFuture{Future: future}
}

func (a *stub) UntagResource(ctx workflow.Context, input *iot.UntagResourceInput) (*iot.UntagResourceOutput, error) {
	var output iot.UntagResourceOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UntagResource", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UntagResourceAsync(ctx workflow.Context, input *iot.UntagResourceInput) *UntagResourceFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UntagResource", input)
	return &UntagResourceFuture{Future: future}
}

func (a *stub) UpdateAccountAuditConfiguration(ctx workflow.Context, input *iot.UpdateAccountAuditConfigurationInput) (*iot.UpdateAccountAuditConfigurationOutput, error) {
	var output iot.UpdateAccountAuditConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateAccountAuditConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateAccountAuditConfigurationAsync(ctx workflow.Context, input *iot.UpdateAccountAuditConfigurationInput) *UpdateAccountAuditConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateAccountAuditConfiguration", input)
	return &UpdateAccountAuditConfigurationFuture{Future: future}
}

func (a *stub) UpdateAuditSuppression(ctx workflow.Context, input *iot.UpdateAuditSuppressionInput) (*iot.UpdateAuditSuppressionOutput, error) {
	var output iot.UpdateAuditSuppressionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateAuditSuppression", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateAuditSuppressionAsync(ctx workflow.Context, input *iot.UpdateAuditSuppressionInput) *UpdateAuditSuppressionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateAuditSuppression", input)
	return &UpdateAuditSuppressionFuture{Future: future}
}

func (a *stub) UpdateAuthorizer(ctx workflow.Context, input *iot.UpdateAuthorizerInput) (*iot.UpdateAuthorizerOutput, error) {
	var output iot.UpdateAuthorizerOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateAuthorizer", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateAuthorizerAsync(ctx workflow.Context, input *iot.UpdateAuthorizerInput) *UpdateAuthorizerFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateAuthorizer", input)
	return &UpdateAuthorizerFuture{Future: future}
}

func (a *stub) UpdateBillingGroup(ctx workflow.Context, input *iot.UpdateBillingGroupInput) (*iot.UpdateBillingGroupOutput, error) {
	var output iot.UpdateBillingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateBillingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateBillingGroupAsync(ctx workflow.Context, input *iot.UpdateBillingGroupInput) *UpdateBillingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateBillingGroup", input)
	return &UpdateBillingGroupFuture{Future: future}
}

func (a *stub) UpdateCACertificate(ctx workflow.Context, input *iot.UpdateCACertificateInput) (*iot.UpdateCACertificateOutput, error) {
	var output iot.UpdateCACertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateCACertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateCACertificateAsync(ctx workflow.Context, input *iot.UpdateCACertificateInput) *UpdateCACertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateCACertificate", input)
	return &UpdateCACertificateFuture{Future: future}
}

func (a *stub) UpdateCertificate(ctx workflow.Context, input *iot.UpdateCertificateInput) (*iot.UpdateCertificateOutput, error) {
	var output iot.UpdateCertificateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateCertificate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateCertificateAsync(ctx workflow.Context, input *iot.UpdateCertificateInput) *UpdateCertificateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateCertificate", input)
	return &UpdateCertificateFuture{Future: future}
}

func (a *stub) UpdateDimension(ctx workflow.Context, input *iot.UpdateDimensionInput) (*iot.UpdateDimensionOutput, error) {
	var output iot.UpdateDimensionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateDimension", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateDimensionAsync(ctx workflow.Context, input *iot.UpdateDimensionInput) *UpdateDimensionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateDimension", input)
	return &UpdateDimensionFuture{Future: future}
}

func (a *stub) UpdateDomainConfiguration(ctx workflow.Context, input *iot.UpdateDomainConfigurationInput) (*iot.UpdateDomainConfigurationOutput, error) {
	var output iot.UpdateDomainConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateDomainConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateDomainConfigurationAsync(ctx workflow.Context, input *iot.UpdateDomainConfigurationInput) *UpdateDomainConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateDomainConfiguration", input)
	return &UpdateDomainConfigurationFuture{Future: future}
}

func (a *stub) UpdateDynamicThingGroup(ctx workflow.Context, input *iot.UpdateDynamicThingGroupInput) (*iot.UpdateDynamicThingGroupOutput, error) {
	var output iot.UpdateDynamicThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateDynamicThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateDynamicThingGroupAsync(ctx workflow.Context, input *iot.UpdateDynamicThingGroupInput) *UpdateDynamicThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateDynamicThingGroup", input)
	return &UpdateDynamicThingGroupFuture{Future: future}
}

func (a *stub) UpdateEventConfigurations(ctx workflow.Context, input *iot.UpdateEventConfigurationsInput) (*iot.UpdateEventConfigurationsOutput, error) {
	var output iot.UpdateEventConfigurationsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateEventConfigurations", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateEventConfigurationsAsync(ctx workflow.Context, input *iot.UpdateEventConfigurationsInput) *UpdateEventConfigurationsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateEventConfigurations", input)
	return &UpdateEventConfigurationsFuture{Future: future}
}

func (a *stub) UpdateIndexingConfiguration(ctx workflow.Context, input *iot.UpdateIndexingConfigurationInput) (*iot.UpdateIndexingConfigurationOutput, error) {
	var output iot.UpdateIndexingConfigurationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateIndexingConfiguration", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateIndexingConfigurationAsync(ctx workflow.Context, input *iot.UpdateIndexingConfigurationInput) *UpdateIndexingConfigurationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateIndexingConfiguration", input)
	return &UpdateIndexingConfigurationFuture{Future: future}
}

func (a *stub) UpdateJob(ctx workflow.Context, input *iot.UpdateJobInput) (*iot.UpdateJobOutput, error) {
	var output iot.UpdateJobOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateJob", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateJobAsync(ctx workflow.Context, input *iot.UpdateJobInput) *UpdateJobFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateJob", input)
	return &UpdateJobFuture{Future: future}
}

func (a *stub) UpdateMitigationAction(ctx workflow.Context, input *iot.UpdateMitigationActionInput) (*iot.UpdateMitigationActionOutput, error) {
	var output iot.UpdateMitigationActionOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateMitigationAction", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateMitigationActionAsync(ctx workflow.Context, input *iot.UpdateMitigationActionInput) *UpdateMitigationActionFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateMitigationAction", input)
	return &UpdateMitigationActionFuture{Future: future}
}

func (a *stub) UpdateProvisioningTemplate(ctx workflow.Context, input *iot.UpdateProvisioningTemplateInput) (*iot.UpdateProvisioningTemplateOutput, error) {
	var output iot.UpdateProvisioningTemplateOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateProvisioningTemplate", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateProvisioningTemplateAsync(ctx workflow.Context, input *iot.UpdateProvisioningTemplateInput) *UpdateProvisioningTemplateFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateProvisioningTemplate", input)
	return &UpdateProvisioningTemplateFuture{Future: future}
}

func (a *stub) UpdateRoleAlias(ctx workflow.Context, input *iot.UpdateRoleAliasInput) (*iot.UpdateRoleAliasOutput, error) {
	var output iot.UpdateRoleAliasOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateRoleAlias", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateRoleAliasAsync(ctx workflow.Context, input *iot.UpdateRoleAliasInput) *UpdateRoleAliasFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateRoleAlias", input)
	return &UpdateRoleAliasFuture{Future: future}
}

func (a *stub) UpdateScheduledAudit(ctx workflow.Context, input *iot.UpdateScheduledAuditInput) (*iot.UpdateScheduledAuditOutput, error) {
	var output iot.UpdateScheduledAuditOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateScheduledAudit", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateScheduledAuditAsync(ctx workflow.Context, input *iot.UpdateScheduledAuditInput) *UpdateScheduledAuditFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateScheduledAudit", input)
	return &UpdateScheduledAuditFuture{Future: future}
}

func (a *stub) UpdateSecurityProfile(ctx workflow.Context, input *iot.UpdateSecurityProfileInput) (*iot.UpdateSecurityProfileOutput, error) {
	var output iot.UpdateSecurityProfileOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateSecurityProfile", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateSecurityProfileAsync(ctx workflow.Context, input *iot.UpdateSecurityProfileInput) *UpdateSecurityProfileFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateSecurityProfile", input)
	return &UpdateSecurityProfileFuture{Future: future}
}

func (a *stub) UpdateStream(ctx workflow.Context, input *iot.UpdateStreamInput) (*iot.UpdateStreamOutput, error) {
	var output iot.UpdateStreamOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateStream", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateStreamAsync(ctx workflow.Context, input *iot.UpdateStreamInput) *UpdateStreamFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateStream", input)
	return &UpdateStreamFuture{Future: future}
}

func (a *stub) UpdateThing(ctx workflow.Context, input *iot.UpdateThingInput) (*iot.UpdateThingOutput, error) {
	var output iot.UpdateThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateThingAsync(ctx workflow.Context, input *iot.UpdateThingInput) *UpdateThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateThing", input)
	return &UpdateThingFuture{Future: future}
}

func (a *stub) UpdateThingGroup(ctx workflow.Context, input *iot.UpdateThingGroupInput) (*iot.UpdateThingGroupOutput, error) {
	var output iot.UpdateThingGroupOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateThingGroup", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateThingGroupAsync(ctx workflow.Context, input *iot.UpdateThingGroupInput) *UpdateThingGroupFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateThingGroup", input)
	return &UpdateThingGroupFuture{Future: future}
}

func (a *stub) UpdateThingGroupsForThing(ctx workflow.Context, input *iot.UpdateThingGroupsForThingInput) (*iot.UpdateThingGroupsForThingOutput, error) {
	var output iot.UpdateThingGroupsForThingOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateThingGroupsForThing", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateThingGroupsForThingAsync(ctx workflow.Context, input *iot.UpdateThingGroupsForThingInput) *UpdateThingGroupsForThingFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateThingGroupsForThing", input)
	return &UpdateThingGroupsForThingFuture{Future: future}
}

func (a *stub) UpdateTopicRuleDestination(ctx workflow.Context, input *iot.UpdateTopicRuleDestinationInput) (*iot.UpdateTopicRuleDestinationOutput, error) {
	var output iot.UpdateTopicRuleDestinationOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.UpdateTopicRuleDestination", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) UpdateTopicRuleDestinationAsync(ctx workflow.Context, input *iot.UpdateTopicRuleDestinationInput) *UpdateTopicRuleDestinationFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.UpdateTopicRuleDestination", input)
	return &UpdateTopicRuleDestinationFuture{Future: future}
}

func (a *stub) ValidateSecurityProfileBehaviors(ctx workflow.Context, input *iot.ValidateSecurityProfileBehaviorsInput) (*iot.ValidateSecurityProfileBehaviorsOutput, error) {
	var output iot.ValidateSecurityProfileBehaviorsOutput
	err := workflow.ExecuteActivity(ctx, "aws.iot.ValidateSecurityProfileBehaviors", input).Get(ctx, &output)
	return &output, err
}

func (a *stub) ValidateSecurityProfileBehaviorsAsync(ctx workflow.Context, input *iot.ValidateSecurityProfileBehaviorsInput) *ValidateSecurityProfileBehaviorsFuture {
	future := workflow.ExecuteActivity(ctx, "aws.iot.ValidateSecurityProfileBehaviors", input)
	return &ValidateSecurityProfileBehaviorsFuture{Future: future}
}
