Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AddAttributesActivity

type AddAttributesActivity struct {

	// A list of 1-50 AttributeNameMapping objects that map an existing attribute to a
	// new attribute. The existing attributes remain in the message, so if you want to
	// remove the originals, use RemoveAttributeActivity.
	//
	// This member is required.
	Attributes map[string]string

	// The name of the addAttributes activity.
	//
	// This member is required.
	Name *string

	// The next activity in the pipeline.
	Next *string
}

    An activity that adds other attributes based on existing attributes in the message.

    type BatchPutMessageErrorEntry

    type BatchPutMessageErrorEntry struct {
    
    	// The code associated with the error.
    	ErrorCode *string
    
    	// The message associated with the error.
    	ErrorMessage *string
    
    	// The ID of the message that caused the error. See the value corresponding to the
    	// messageId key in the message object.
    	MessageId *string
    }

      Contains informations about errors.

      type Channel

      type Channel struct {
      
      	// The ARN of the channel.
      	Arn *string
      
      	// When the channel was created.
      	CreationTime *time.Time
      
      	// The last time when a new message arrived in the channel. AWS IoT Analytics
      	// updates this value at most once per minute for one channel. Hence, the
      	// lastMessageArrivalTime value is an approximation. This feature only applies to
      	// messages that arrived in the data store after October 23, 2020.
      	LastMessageArrivalTime *time.Time
      
      	// When the channel was last updated.
      	LastUpdateTime *time.Time
      
      	// The name of the channel.
      	Name *string
      
      	// How long, in days, message data is kept for the channel.
      	RetentionPeriod *RetentionPeriod
      
      	// The status of the channel.
      	Status ChannelStatus
      
      	// Where channel data is stored. You can choose one of serviceManagedS3 or
      	// customerManagedS3 storage. If not specified, the default is serviceManagedS3.
      	// You cannot change this storage option after the channel is created.
      	Storage *ChannelStorage
      }

        A collection of data from an MQTT topic. Channels archive the raw, unprocessed messages before publishing the data to a pipeline.

        type ChannelActivity

        type ChannelActivity struct {
        
        	// The name of the channel from which the messages are processed.
        	//
        	// This member is required.
        	ChannelName *string
        
        	// The name of the channel activity.
        	//
        	// This member is required.
        	Name *string
        
        	// The next activity in the pipeline.
        	Next *string
        }

          The activity that determines the source of the messages to be processed.

          type ChannelMessages

          type ChannelMessages struct {
          
          	// Specifies one or more keys that identify the Amazon Simple Storage Service
          	// (Amazon S3) objects that save your channel messages.
          	S3Paths []string
          }

            Specifies one or more sets of channel messages.

            type ChannelStatistics

            type ChannelStatistics struct {
            
            	// The estimated size of the channel.
            	Size *EstimatedResourceSize
            }

              Statistics information about the channel.

              type ChannelStatus

              type ChannelStatus string
              const (
              	ChannelStatusCreating ChannelStatus = "CREATING"
              	ChannelStatusActive   ChannelStatus = "ACTIVE"
              	ChannelStatusDeleting ChannelStatus = "DELETING"
              )

                Enum values for ChannelStatus

                func (ChannelStatus) Values

                func (ChannelStatus) Values() []ChannelStatus

                  Values returns all known values for ChannelStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                  type ChannelStorage

                  type ChannelStorage struct {
                  
                  	// Use this to store channel data in an S3 bucket that you manage. If customer
                  	// managed storage is selected, the retentionPeriod parameter is ignored. You
                  	// cannot change the choice of service-managed or customer-managed S3 storage after
                  	// the channel is created.
                  	CustomerManagedS3 *CustomerManagedChannelS3Storage
                  
                  	// Use this to store channel data in an S3 bucket managed by AWS IoT Analytics. You
                  	// cannot change the choice of service-managed or customer-managed S3 storage after
                  	// the channel is created.
                  	ServiceManagedS3 *ServiceManagedChannelS3Storage
                  }

                    Where channel data is stored. You may choose one of serviceManagedS3 or customerManagedS3 storage. If not specified, the default is serviceManagedS3. This cannot be changed after creation of the channel.

                    type ChannelStorageSummary

                    type ChannelStorageSummary struct {
                    
                    	// Used to store channel data in an S3 bucket that you manage.
                    	CustomerManagedS3 *CustomerManagedChannelS3StorageSummary
                    
                    	// Used to store channel data in an S3 bucket managed by AWS IoT Analytics.
                    	ServiceManagedS3 *ServiceManagedChannelS3StorageSummary
                    }

                      Where channel data is stored.

                      type ChannelSummary

                      type ChannelSummary struct {
                      
                      	// The name of the channel.
                      	ChannelName *string
                      
                      	// Where channel data is stored.
                      	ChannelStorage *ChannelStorageSummary
                      
                      	// When the channel was created.
                      	CreationTime *time.Time
                      
                      	// The last time when a new message arrived in the channel. AWS IoT Analytics
                      	// updates this value at most once per minute for one channel. Hence, the
                      	// lastMessageArrivalTime value is an approximation. This feature only applies to
                      	// messages that arrived in the data store after October 23, 2020.
                      	LastMessageArrivalTime *time.Time
                      
                      	// The last time the channel was updated.
                      	LastUpdateTime *time.Time
                      
                      	// The status of the channel.
                      	Status ChannelStatus
                      }

                        A summary of information about a channel.

                        type Column

                        type Column struct {
                        
                        	// The name of the column.
                        	//
                        	// This member is required.
                        	Name *string
                        
                        	// The type of data. For more information about the supported data types, see
                        	// Common data types
                        	// (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html) in the AWS
                        	// Glue Developer Guide.
                        	//
                        	// This member is required.
                        	Type *string
                        }

                          Contains information about a column that stores your data.

                          type ComputeType

                          type ComputeType string
                          const (
                          	ComputeTypeAcu1 ComputeType = "ACU_1"
                          	ComputeTypeAcu2 ComputeType = "ACU_2"
                          )

                            Enum values for ComputeType

                            func (ComputeType) Values

                            func (ComputeType) Values() []ComputeType

                              Values returns all known values for ComputeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                              type ContainerDatasetAction

                              type ContainerDatasetAction struct {
                              
                              	// The ARN of the role that gives permission to the system to access required
                              	// resources to run the containerAction. This includes, at minimum, permission to
                              	// retrieve the dataset contents that are the input to the containerized
                              	// application.
                              	//
                              	// This member is required.
                              	ExecutionRoleArn *string
                              
                              	// The ARN of the Docker container stored in your account. The Docker container
                              	// contains an application and required support libraries and is used to generate
                              	// dataset contents.
                              	//
                              	// This member is required.
                              	Image *string
                              
                              	// Configuration of the resource that executes the containerAction.
                              	//
                              	// This member is required.
                              	ResourceConfiguration *ResourceConfiguration
                              
                              	// The values of variables used in the context of the execution of the
                              	// containerized application (basically, parameters passed to the application).
                              	// Each variable must have a name and a value given by one of stringValue,
                              	// datasetContentVersionValue, or outputFileUriValue.
                              	Variables []Variable
                              }

                                Information required to run the containerAction to produce dataset contents.

                                type CustomerManagedChannelS3Storage

                                type CustomerManagedChannelS3Storage struct {
                                
                                	// The name of the S3 bucket in which channel data is stored.
                                	//
                                	// This member is required.
                                	Bucket *string
                                
                                	// The ARN of the role that grants AWS IoT Analytics permission to interact with
                                	// your Amazon S3 resources.
                                	//
                                	// This member is required.
                                	RoleArn *string
                                
                                	// Optional. The prefix used to create the keys of the channel data objects. Each
                                	// object in an S3 bucket has a key that is its unique identifier in the bucket.
                                	// Each object in a bucket has exactly one key. The prefix must end with a forward
                                	// slash (/).
                                	KeyPrefix *string
                                }

                                  Use this to store channel data in an S3 bucket that you manage. If customer managed storage is selected, the retentionPeriod parameter is ignored. You cannot change the choice of service-managed or customer-managed S3 storage after the channel is created.

                                  type CustomerManagedChannelS3StorageSummary

                                  type CustomerManagedChannelS3StorageSummary struct {
                                  
                                  	// The name of the S3 bucket in which channel data is stored.
                                  	Bucket *string
                                  
                                  	// Optional. The prefix used to create the keys of the channel data objects. Each
                                  	// object in an S3 bucket has a key that is its unique identifier within the bucket
                                  	// (each object in a bucket has exactly one key). The prefix must end with a
                                  	// forward slash (/).
                                  	KeyPrefix *string
                                  
                                  	// The ARN of the role that grants AWS IoT Analytics permission to interact with
                                  	// your Amazon S3 resources.
                                  	RoleArn *string
                                  }

                                    Used to store channel data in an S3 bucket that you manage.

                                    type CustomerManagedDatastoreS3Storage

                                    type CustomerManagedDatastoreS3Storage struct {
                                    
                                    	// The name of the S3 bucket in which data store data is stored.
                                    	//
                                    	// This member is required.
                                    	Bucket *string
                                    
                                    	// The ARN of the role that grants AWS IoT Analytics permission to interact with
                                    	// your Amazon S3 resources.
                                    	//
                                    	// This member is required.
                                    	RoleArn *string
                                    
                                    	// Optional. The prefix used to create the keys of the data store data objects.
                                    	// Each object in an S3 bucket has a key that is its unique identifier in the
                                    	// bucket. Each object in a bucket has exactly one key. The prefix must end with a
                                    	// forward slash (/).
                                    	KeyPrefix *string
                                    }

                                      Use this to store data store data in an S3 bucket that you manage. When customer-managed storage is selected, the retentionPeriod parameter is ignored. You cannot change the choice of service-managed or customer-managed S3 storage after the data store is created.

                                      type CustomerManagedDatastoreS3StorageSummary

                                      type CustomerManagedDatastoreS3StorageSummary struct {
                                      
                                      	// The name of the S3 bucket in which data store data is stored.
                                      	Bucket *string
                                      
                                      	// Optional. The prefix used to create the keys of the data store data objects.
                                      	// Each object in an S3 bucket has a key that is its unique identifier in the
                                      	// bucket. Each object in a bucket has exactly one key. The prefix must end with a
                                      	// forward slash (/).
                                      	KeyPrefix *string
                                      
                                      	// The ARN of the role that grants AWS IoT Analytics permission to interact with
                                      	// your Amazon S3 resources.
                                      	RoleArn *string
                                      }

                                        Used to store data store data in an S3 bucket that you manage.

                                        type Dataset

                                        type Dataset struct {
                                        
                                        	// The DatasetAction objects that automatically create the data set contents.
                                        	Actions []DatasetAction
                                        
                                        	// The ARN of the data set.
                                        	Arn *string
                                        
                                        	// When dataset contents are created they are delivered to destinations specified
                                        	// here.
                                        	ContentDeliveryRules []DatasetContentDeliveryRule
                                        
                                        	// When the data set was created.
                                        	CreationTime *time.Time
                                        
                                        	// The last time the data set was updated.
                                        	LastUpdateTime *time.Time
                                        
                                        	// A list of data rules that send notifications to Amazon CloudWatch, when data
                                        	// arrives late. To specify lateDataRules, the dataset must use a DeltaTimer
                                        	// (https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html)
                                        	// filter.
                                        	LateDataRules []LateDataRule
                                        
                                        	// The name of the data set.
                                        	Name *string
                                        
                                        	// Optional. How long, in days, message data is kept for the data set.
                                        	RetentionPeriod *RetentionPeriod
                                        
                                        	// The status of the data set.
                                        	Status DatasetStatus
                                        
                                        	// The DatasetTrigger objects that specify when the data set is automatically
                                        	// updated.
                                        	Triggers []DatasetTrigger
                                        
                                        	// Optional. How many versions of dataset contents are kept. If not specified or
                                        	// set to null, only the latest version plus the latest succeeded version (if they
                                        	// are different) are kept for the time period specified by the retentionPeriod
                                        	// parameter. For more information, see Keeping Multiple Versions of AWS IoT
                                        	// Analytics Data Sets
                                        	// (https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions)
                                        	// in the AWS IoT Analytics User Guide.
                                        	VersioningConfiguration *VersioningConfiguration
                                        }

                                          Information about a data set.

                                          type DatasetAction

                                          type DatasetAction struct {
                                          
                                          	// The name of the data set action by which data set contents are automatically
                                          	// created.
                                          	ActionName *string
                                          
                                          	// Information that allows the system to run a containerized application to create
                                          	// the dataset contents. The application must be in a Docker container along with
                                          	// any required support libraries.
                                          	ContainerAction *ContainerDatasetAction
                                          
                                          	// An SqlQueryDatasetAction object that uses an SQL query to automatically create
                                          	// data set contents.
                                          	QueryAction *SqlQueryDatasetAction
                                          }

                                            A DatasetAction object that specifies how data set contents are automatically created.

                                            type DatasetActionSummary

                                            type DatasetActionSummary struct {
                                            
                                            	// The name of the action that automatically creates the dataset's contents.
                                            	ActionName *string
                                            
                                            	// The type of action by which the dataset's contents are automatically created.
                                            	ActionType DatasetActionType
                                            }

                                              Information about the action that automatically creates the dataset's contents.

                                              type DatasetActionType

                                              type DatasetActionType string
                                              const (
                                              	DatasetActionTypeQuery     DatasetActionType = "QUERY"
                                              	DatasetActionTypeContainer DatasetActionType = "CONTAINER"
                                              )

                                                Enum values for DatasetActionType

                                                func (DatasetActionType) Values

                                                  Values returns all known values for DatasetActionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                  type DatasetContentDeliveryDestination

                                                  type DatasetContentDeliveryDestination struct {
                                                  
                                                  	// Configuration information for delivery of dataset contents to AWS IoT Events.
                                                  	IotEventsDestinationConfiguration *IotEventsDestinationConfiguration
                                                  
                                                  	// Configuration information for delivery of dataset contents to Amazon S3.
                                                  	S3DestinationConfiguration *S3DestinationConfiguration
                                                  }

                                                    The destination to which dataset contents are delivered.

                                                    type DatasetContentDeliveryRule

                                                    type DatasetContentDeliveryRule struct {
                                                    
                                                    	// The destination to which dataset contents are delivered.
                                                    	//
                                                    	// This member is required.
                                                    	Destination *DatasetContentDeliveryDestination
                                                    
                                                    	// The name of the dataset content delivery rules entry.
                                                    	EntryName *string
                                                    }

                                                      When dataset contents are created, they are delivered to destination specified here.

                                                      type DatasetContentState

                                                      type DatasetContentState string
                                                      const (
                                                      	DatasetContentStateCreating  DatasetContentState = "CREATING"
                                                      	DatasetContentStateSucceeded DatasetContentState = "SUCCEEDED"
                                                      	DatasetContentStateFailed    DatasetContentState = "FAILED"
                                                      )

                                                        Enum values for DatasetContentState

                                                        func (DatasetContentState) Values

                                                          Values returns all known values for DatasetContentState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type DatasetContentStatus

                                                          type DatasetContentStatus struct {
                                                          
                                                          	// The reason the data set contents are in this state.
                                                          	Reason *string
                                                          
                                                          	// The state of the data set contents. Can be one of READY, CREATING, SUCCEEDED, or
                                                          	// FAILED.
                                                          	State DatasetContentState
                                                          }

                                                            The state of the data set contents and the reason they are in this state.

                                                            type DatasetContentSummary

                                                            type DatasetContentSummary struct {
                                                            
                                                            	// The time the dataset content status was updated to SUCCEEDED or FAILED.
                                                            	CompletionTime *time.Time
                                                            
                                                            	// The actual time the creation of the dataset contents was started.
                                                            	CreationTime *time.Time
                                                            
                                                            	// The time the creation of the dataset contents was scheduled to start.
                                                            	ScheduleTime *time.Time
                                                            
                                                            	// The status of the data set contents.
                                                            	Status *DatasetContentStatus
                                                            
                                                            	// The version of the dataset contents.
                                                            	Version *string
                                                            }

                                                              Summary information about dataset contents.

                                                              type DatasetContentVersionValue

                                                              type DatasetContentVersionValue struct {
                                                              
                                                              	// The name of the dataset whose latest contents are used as input to the notebook
                                                              	// or application.
                                                              	//
                                                              	// This member is required.
                                                              	DatasetName *string
                                                              }

                                                                The dataset whose latest contents are used as input to the notebook or application.

                                                                type DatasetEntry

                                                                type DatasetEntry struct {
                                                                
                                                                	// The presigned URI of the data set item.
                                                                	DataURI *string
                                                                
                                                                	// The name of the data set item.
                                                                	EntryName *string
                                                                }

                                                                  The reference to a data set entry.

                                                                  type DatasetStatus

                                                                  type DatasetStatus string
                                                                  const (
                                                                  	DatasetStatusCreating DatasetStatus = "CREATING"
                                                                  	DatasetStatusActive   DatasetStatus = "ACTIVE"
                                                                  	DatasetStatusDeleting DatasetStatus = "DELETING"
                                                                  )

                                                                    Enum values for DatasetStatus

                                                                    func (DatasetStatus) Values

                                                                    func (DatasetStatus) Values() []DatasetStatus

                                                                      Values returns all known values for DatasetStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type DatasetSummary

                                                                      type DatasetSummary struct {
                                                                      
                                                                      	// A list of DataActionSummary objects.
                                                                      	Actions []DatasetActionSummary
                                                                      
                                                                      	// The time the data set was created.
                                                                      	CreationTime *time.Time
                                                                      
                                                                      	// The name of the data set.
                                                                      	DatasetName *string
                                                                      
                                                                      	// The last time the data set was updated.
                                                                      	LastUpdateTime *time.Time
                                                                      
                                                                      	// The status of the data set.
                                                                      	Status DatasetStatus
                                                                      
                                                                      	// A list of triggers. A trigger causes data set content to be populated at a
                                                                      	// specified time interval or when another data set is populated. The list of
                                                                      	// triggers can be empty or contain up to five DataSetTrigger objects
                                                                      	Triggers []DatasetTrigger
                                                                      }

                                                                        A summary of information about a data set.

                                                                        type DatasetTrigger

                                                                        type DatasetTrigger struct {
                                                                        
                                                                        	// The data set whose content creation triggers the creation of this data set's
                                                                        	// contents.
                                                                        	Dataset *TriggeringDataset
                                                                        
                                                                        	// The Schedule when the trigger is initiated.
                                                                        	Schedule *Schedule
                                                                        }

                                                                          The DatasetTrigger that specifies when the data set is automatically updated.

                                                                          type Datastore

                                                                          type Datastore struct {
                                                                          
                                                                          	// The ARN of the data store.
                                                                          	Arn *string
                                                                          
                                                                          	// When the data store was created.
                                                                          	CreationTime *time.Time
                                                                          
                                                                          	// Contains the configuration information of file formats. AWS IoT Analytics data
                                                                          	// stores support JSON and Parquet (https://parquet.apache.org/). The default file
                                                                          	// format is JSON. You can specify only one format. You can't change the file
                                                                          	// format after you create the data store.
                                                                          	FileFormatConfiguration *FileFormatConfiguration
                                                                          
                                                                          	// The last time when a new message arrived in the data store. AWS IoT Analytics
                                                                          	// updates this value at most once per minute for one data store. Hence, the
                                                                          	// lastMessageArrivalTime value is an approximation. This feature only applies to
                                                                          	// messages that arrived in the data store after October 23, 2020.
                                                                          	LastMessageArrivalTime *time.Time
                                                                          
                                                                          	// The last time the data store was updated.
                                                                          	LastUpdateTime *time.Time
                                                                          
                                                                          	// The name of the data store.
                                                                          	Name *string
                                                                          
                                                                          	// How long, in days, message data is kept for the data store. When
                                                                          	// customerManagedS3 storage is selected, this parameter is ignored.
                                                                          	RetentionPeriod *RetentionPeriod
                                                                          
                                                                          	// The status of a data store: CREATING The data store is being created. ACTIVE The
                                                                          	// data store has been created and can be used. DELETING The data store is being
                                                                          	// deleted.
                                                                          	Status DatastoreStatus
                                                                          
                                                                          	// Where data store data is stored. You can choose one of serviceManagedS3 or
                                                                          	// customerManagedS3 storage. If not specified, the default is serviceManagedS3.
                                                                          	// You cannot change this storage option after the data store is created.
                                                                          	Storage DatastoreStorage
                                                                          }

                                                                            Information about a data store.

                                                                            type DatastoreActivity

                                                                            type DatastoreActivity struct {
                                                                            
                                                                            	// The name of the data store where processed messages are stored.
                                                                            	//
                                                                            	// This member is required.
                                                                            	DatastoreName *string
                                                                            
                                                                            	// The name of the datastore activity.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Name *string
                                                                            }

                                                                              The datastore activity that specifies where to store the processed data.

                                                                              type DatastoreStatistics

                                                                              type DatastoreStatistics struct {
                                                                              
                                                                              	// The estimated size of the data store.
                                                                              	Size *EstimatedResourceSize
                                                                              }

                                                                                Statistical information about the data store.

                                                                                type DatastoreStatus

                                                                                type DatastoreStatus string
                                                                                const (
                                                                                	DatastoreStatusCreating DatastoreStatus = "CREATING"
                                                                                	DatastoreStatusActive   DatastoreStatus = "ACTIVE"
                                                                                	DatastoreStatusDeleting DatastoreStatus = "DELETING"
                                                                                )

                                                                                  Enum values for DatastoreStatus

                                                                                  func (DatastoreStatus) Values

                                                                                  func (DatastoreStatus) Values() []DatastoreStatus

                                                                                    Values returns all known values for DatastoreStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                    type DatastoreStorage

                                                                                    type DatastoreStorage interface {
                                                                                    	// contains filtered or unexported methods
                                                                                    }

                                                                                      Where data store data is stored. You can choose one of serviceManagedS3 or customerManagedS3 storage. If not specified, the default is serviceManagedS3. You cannot change this storage option after the data store is created.

                                                                                      The following types satisfy this interface:

                                                                                      DatastoreStorageMemberServiceManagedS3
                                                                                      DatastoreStorageMemberCustomerManagedS3
                                                                                      
                                                                                      Example (OutputUsage)
                                                                                      Output:
                                                                                      
                                                                                      

                                                                                      type DatastoreStorageMemberCustomerManagedS3

                                                                                      type DatastoreStorageMemberCustomerManagedS3 struct {
                                                                                      	Value CustomerManagedDatastoreS3Storage
                                                                                      }

                                                                                        Use this to store data store data in an S3 bucket that you manage. When customer managed storage is selected, the retentionPeriod parameter is ignored. The choice of service-managed or customer-managed S3 storage cannot be changed after creation of the data store.

                                                                                        type DatastoreStorageMemberServiceManagedS3

                                                                                        type DatastoreStorageMemberServiceManagedS3 struct {
                                                                                        	Value ServiceManagedDatastoreS3Storage
                                                                                        }

                                                                                          Use this to store data store data in an S3 bucket managed by AWS IoT Analytics. You cannot change the choice of service-managed or customer-managed S3 storage after the data store is created.

                                                                                          type DatastoreStorageSummary

                                                                                          type DatastoreStorageSummary struct {
                                                                                          
                                                                                          	// Used to store data store data in an S3 bucket that you manage.
                                                                                          	CustomerManagedS3 *CustomerManagedDatastoreS3StorageSummary
                                                                                          
                                                                                          	// Used to store data store data in an S3 bucket managed by AWS IoT Analytics.
                                                                                          	ServiceManagedS3 *ServiceManagedDatastoreS3StorageSummary
                                                                                          }

                                                                                            Where data store data is stored.

                                                                                            type DatastoreSummary

                                                                                            type DatastoreSummary struct {
                                                                                            
                                                                                            	// When the data store was created.
                                                                                            	CreationTime *time.Time
                                                                                            
                                                                                            	// The name of the data store.
                                                                                            	DatastoreName *string
                                                                                            
                                                                                            	// Where data store data is stored.
                                                                                            	DatastoreStorage *DatastoreStorageSummary
                                                                                            
                                                                                            	// The file format of the data in the data store.
                                                                                            	FileFormatType FileFormatType
                                                                                            
                                                                                            	// The last time when a new message arrived in the data store. AWS IoT Analytics
                                                                                            	// updates this value at most once per minute for one data store. Hence, the
                                                                                            	// lastMessageArrivalTime value is an approximation. This feature only applies to
                                                                                            	// messages that arrived in the data store after October 23, 2020.
                                                                                            	LastMessageArrivalTime *time.Time
                                                                                            
                                                                                            	// The last time the data store was updated.
                                                                                            	LastUpdateTime *time.Time
                                                                                            
                                                                                            	// The status of the data store.
                                                                                            	Status DatastoreStatus
                                                                                            }

                                                                                              A summary of information about a data store.

                                                                                              type DeltaTime

                                                                                              type DeltaTime struct {
                                                                                              
                                                                                              	// The number of seconds of estimated in-flight lag time of message data. When you
                                                                                              	// create dataset contents using message data from a specified timeframe, some
                                                                                              	// message data might still be in flight when processing begins, and so do not
                                                                                              	// arrive in time to be processed. Use this field to make allowances for the in
                                                                                              	// flight time of your message data, so that data not processed from a previous
                                                                                              	// timeframe is included with the next timeframe. Otherwise, missed message data
                                                                                              	// would be excluded from processing during the next timeframe too, because its
                                                                                              	// timestamp places it within the previous timeframe.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	OffsetSeconds *int32
                                                                                              
                                                                                              	// An expression by which the time of the message data might be determined. This
                                                                                              	// can be the name of a timestamp field or a SQL expression that is used to derive
                                                                                              	// the time the message data was generated.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	TimeExpression *string
                                                                                              }

                                                                                                Used to limit data to that which has arrived since the last execution of the action.

                                                                                                type DeltaTimeSessionWindowConfiguration

                                                                                                type DeltaTimeSessionWindowConfiguration struct {
                                                                                                
                                                                                                	// A time interval. You can use timeoutInMinutes so that AWS IoT Analytics can
                                                                                                	// batch up late data notifications that have been generated since the last
                                                                                                	// execution. AWS IoT Analytics sends one batch of notifications to Amazon
                                                                                                	// CloudWatch Events at one time. For more information about how to write a
                                                                                                	// timestamp expression, see Date and Time Functions and Operators
                                                                                                	// (https://prestodb.io/docs/0.172/functions/datetime.html), in the Presto 0.172
                                                                                                	// Documentation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	TimeoutInMinutes *int32
                                                                                                }

                                                                                                  A structure that contains the configuration information of a delta time session window. DeltaTime (https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html) specifies a time interval. You can use DeltaTime to create dataset contents with data that has arrived in the data store since the last execution. For an example of DeltaTime, see Creating a SQL dataset with a delta window (CLI) (https://docs.aws.amazon.com/iotanalytics/latest/userguide/automate-create-dataset.html#automate-example6) in the AWS IoT Analytics User Guide.

                                                                                                  type DeviceRegistryEnrichActivity

                                                                                                  type DeviceRegistryEnrichActivity struct {
                                                                                                  
                                                                                                  	// The name of the attribute that is added to the message.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	Attribute *string
                                                                                                  
                                                                                                  	// The name of the deviceRegistryEnrich activity.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	Name *string
                                                                                                  
                                                                                                  	// The ARN of the role that allows access to the device's registry information.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	RoleArn *string
                                                                                                  
                                                                                                  	// The name of the IoT device whose registry information is added to the message.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	ThingName *string
                                                                                                  
                                                                                                  	// The next activity in the pipeline.
                                                                                                  	Next *string
                                                                                                  }

                                                                                                    An activity that adds data from the AWS IoT device registry to your message.

                                                                                                    type DeviceShadowEnrichActivity

                                                                                                    type DeviceShadowEnrichActivity struct {
                                                                                                    
                                                                                                    	// The name of the attribute that is added to the message.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Attribute *string
                                                                                                    
                                                                                                    	// The name of the deviceShadowEnrich activity.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Name *string
                                                                                                    
                                                                                                    	// The ARN of the role that allows access to the device's shadow.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	RoleArn *string
                                                                                                    
                                                                                                    	// The name of the IoT device whose shadow information is added to the message.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	ThingName *string
                                                                                                    
                                                                                                    	// The next activity in the pipeline.
                                                                                                    	Next *string
                                                                                                    }

                                                                                                      An activity that adds information from the AWS IoT Device Shadow service to a message.

                                                                                                      type EstimatedResourceSize

                                                                                                      type EstimatedResourceSize struct {
                                                                                                      
                                                                                                      	// The time when the estimate of the size of the resource was made.
                                                                                                      	EstimatedOn *time.Time
                                                                                                      
                                                                                                      	// The estimated size of the resource, in bytes.
                                                                                                      	EstimatedSizeInBytes *float64
                                                                                                      }

                                                                                                        The estimated size of the resource.

                                                                                                        type FileFormatConfiguration

                                                                                                        type FileFormatConfiguration struct {
                                                                                                        
                                                                                                        	// Contains the configuration information of the JSON format.
                                                                                                        	JsonConfiguration *JsonConfiguration
                                                                                                        
                                                                                                        	// Contains the configuration information of the Parquet format.
                                                                                                        	ParquetConfiguration *ParquetConfiguration
                                                                                                        }

                                                                                                          Contains the configuration information of file formats. AWS IoT Analytics data stores support JSON and Parquet (https://parquet.apache.org/). The default file format is JSON. You can specify only one format. You can't change the file format after you create the data store.

                                                                                                          type FileFormatType

                                                                                                          type FileFormatType string
                                                                                                          const (
                                                                                                          	FileFormatTypeJson    FileFormatType = "JSON"
                                                                                                          	FileFormatTypeParquet FileFormatType = "PARQUET"
                                                                                                          )

                                                                                                            Enum values for FileFormatType

                                                                                                            func (FileFormatType) Values

                                                                                                            func (FileFormatType) Values() []FileFormatType

                                                                                                              Values returns all known values for FileFormatType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                              type FilterActivity

                                                                                                              type FilterActivity struct {
                                                                                                              
                                                                                                              	// An expression that looks like a SQL WHERE clause that must return a Boolean
                                                                                                              	// value. Messages that satisfy the condition are passed to the next activity.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Filter *string
                                                                                                              
                                                                                                              	// The name of the filter activity.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Name *string
                                                                                                              
                                                                                                              	// The next activity in the pipeline.
                                                                                                              	Next *string
                                                                                                              }

                                                                                                                An activity that filters a message based on its attributes.

                                                                                                                type GlueConfiguration

                                                                                                                type GlueConfiguration struct {
                                                                                                                
                                                                                                                	// The name of the database in your AWS Glue Data Catalog in which the table is
                                                                                                                	// located. An AWS Glue Data Catalog database contains metadata tables.
                                                                                                                	//
                                                                                                                	// This member is required.
                                                                                                                	DatabaseName *string
                                                                                                                
                                                                                                                	// The name of the table in your AWS Glue Data Catalog that is used to perform the
                                                                                                                	// ETL operations. An AWS Glue Data Catalog table contains partitioned data and
                                                                                                                	// descriptions of data sources and targets.
                                                                                                                	//
                                                                                                                	// This member is required.
                                                                                                                	TableName *string
                                                                                                                }

                                                                                                                  Configuration information for coordination with AWS Glue, a fully managed extract, transform and load (ETL) service.

                                                                                                                  type InternalFailureException

                                                                                                                  type InternalFailureException struct {
                                                                                                                  	Message *string
                                                                                                                  }

                                                                                                                    There was an internal failure.

                                                                                                                    func (*InternalFailureException) Error

                                                                                                                    func (e *InternalFailureException) Error() string

                                                                                                                    func (*InternalFailureException) ErrorCode

                                                                                                                    func (e *InternalFailureException) ErrorCode() string

                                                                                                                    func (*InternalFailureException) ErrorFault

                                                                                                                    func (e *InternalFailureException) ErrorFault() smithy.ErrorFault

                                                                                                                    func (*InternalFailureException) ErrorMessage

                                                                                                                    func (e *InternalFailureException) ErrorMessage() string

                                                                                                                    type InvalidRequestException

                                                                                                                    type InvalidRequestException struct {
                                                                                                                    	Message *string
                                                                                                                    }

                                                                                                                      The request was not valid.

                                                                                                                      func (*InvalidRequestException) Error

                                                                                                                      func (e *InvalidRequestException) Error() string

                                                                                                                      func (*InvalidRequestException) ErrorCode

                                                                                                                      func (e *InvalidRequestException) ErrorCode() string

                                                                                                                      func (*InvalidRequestException) ErrorFault

                                                                                                                      func (e *InvalidRequestException) ErrorFault() smithy.ErrorFault

                                                                                                                      func (*InvalidRequestException) ErrorMessage

                                                                                                                      func (e *InvalidRequestException) ErrorMessage() string

                                                                                                                      type IotEventsDestinationConfiguration

                                                                                                                      type IotEventsDestinationConfiguration struct {
                                                                                                                      
                                                                                                                      	// The name of the AWS IoT Events input to which dataset contents are delivered.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	InputName *string
                                                                                                                      
                                                                                                                      	// The ARN of the role that grants AWS IoT Analytics permission to deliver dataset
                                                                                                                      	// contents to an AWS IoT Events input.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	RoleArn *string
                                                                                                                      }

                                                                                                                        Configuration information for delivery of dataset contents to AWS IoT Events.

                                                                                                                        type JsonConfiguration

                                                                                                                        type JsonConfiguration struct {
                                                                                                                        }

                                                                                                                          Contains the configuration information of the JSON format.

                                                                                                                          type LambdaActivity

                                                                                                                          type LambdaActivity struct {
                                                                                                                          
                                                                                                                          	// The number of messages passed to the Lambda function for processing. The Lambda
                                                                                                                          	// function must be able to process all of these messages within five minutes,
                                                                                                                          	// which is the maximum timeout duration for Lambda functions.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	BatchSize *int32
                                                                                                                          
                                                                                                                          	// The name of the Lambda function that is run on the message.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	LambdaName *string
                                                                                                                          
                                                                                                                          	// The name of the lambda activity.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Name *string
                                                                                                                          
                                                                                                                          	// The next activity in the pipeline.
                                                                                                                          	Next *string
                                                                                                                          }

                                                                                                                            An activity that runs a Lambda function to modify the message.

                                                                                                                            type LateDataRule

                                                                                                                            type LateDataRule struct {
                                                                                                                            
                                                                                                                            	// The information needed to configure the late data rule.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	RuleConfiguration *LateDataRuleConfiguration
                                                                                                                            
                                                                                                                            	// The name of the late data rule.
                                                                                                                            	RuleName *string
                                                                                                                            }

                                                                                                                              A structure that contains the name and configuration information of a late data rule.

                                                                                                                              type LateDataRuleConfiguration

                                                                                                                              type LateDataRuleConfiguration struct {
                                                                                                                              
                                                                                                                              	// The information needed to configure a delta time session window.
                                                                                                                              	DeltaTimeSessionWindowConfiguration *DeltaTimeSessionWindowConfiguration
                                                                                                                              }

                                                                                                                                The information needed to configure a delta time session window.

                                                                                                                                type LimitExceededException

                                                                                                                                type LimitExceededException struct {
                                                                                                                                	Message *string
                                                                                                                                }

                                                                                                                                  The command caused an internal limit to be exceeded.

                                                                                                                                  func (*LimitExceededException) Error

                                                                                                                                  func (e *LimitExceededException) Error() string

                                                                                                                                  func (*LimitExceededException) ErrorCode

                                                                                                                                  func (e *LimitExceededException) ErrorCode() string

                                                                                                                                  func (*LimitExceededException) ErrorFault

                                                                                                                                  func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                                                                  func (*LimitExceededException) ErrorMessage

                                                                                                                                  func (e *LimitExceededException) ErrorMessage() string

                                                                                                                                  type LoggingLevel

                                                                                                                                  type LoggingLevel string
                                                                                                                                  const (
                                                                                                                                  	LoggingLevelError LoggingLevel = "ERROR"
                                                                                                                                  )

                                                                                                                                    Enum values for LoggingLevel

                                                                                                                                    func (LoggingLevel) Values

                                                                                                                                    func (LoggingLevel) Values() []LoggingLevel

                                                                                                                                      Values returns all known values for LoggingLevel. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                      type LoggingOptions

                                                                                                                                      type LoggingOptions struct {
                                                                                                                                      
                                                                                                                                      	// If true, logging is enabled for AWS IoT Analytics.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Enabled bool
                                                                                                                                      
                                                                                                                                      	// The logging level. Currently, only ERROR is supported.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	Level LoggingLevel
                                                                                                                                      
                                                                                                                                      	// The ARN of the role that grants permission to AWS IoT Analytics to perform
                                                                                                                                      	// logging.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	RoleArn *string
                                                                                                                                      }

                                                                                                                                        Information about logging options.

                                                                                                                                        type MathActivity

                                                                                                                                        type MathActivity struct {
                                                                                                                                        
                                                                                                                                        	// The name of the attribute that contains the result of the math operation.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	Attribute *string
                                                                                                                                        
                                                                                                                                        	// An expression that uses one or more existing attributes and must return an
                                                                                                                                        	// integer value.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	Math *string
                                                                                                                                        
                                                                                                                                        	// The name of the math activity.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	Name *string
                                                                                                                                        
                                                                                                                                        	// The next activity in the pipeline.
                                                                                                                                        	Next *string
                                                                                                                                        }

                                                                                                                                          An activity that computes an arithmetic expression using the message's attributes.

                                                                                                                                          type Message

                                                                                                                                          type Message struct {
                                                                                                                                          
                                                                                                                                          	// The ID you want to assign to the message. Each messageId must be unique within
                                                                                                                                          	// each batch sent.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	MessageId *string
                                                                                                                                          
                                                                                                                                          	// The payload of the message. This can be a JSON string or a base64-encoded string
                                                                                                                                          	// representing binary data, in which case you must decode it by means of a
                                                                                                                                          	// pipeline activity.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Payload []byte
                                                                                                                                          }

                                                                                                                                            Information about a message.

                                                                                                                                            type OutputFileUriValue

                                                                                                                                            type OutputFileUriValue struct {
                                                                                                                                            
                                                                                                                                            	// The URI of the location where dataset contents are stored, usually the URI of a
                                                                                                                                            	// file in an S3 bucket.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FileName *string
                                                                                                                                            }

                                                                                                                                              The value of the variable as a structure that specifies an output file URI.

                                                                                                                                              type ParquetConfiguration

                                                                                                                                              type ParquetConfiguration struct {
                                                                                                                                              
                                                                                                                                              	// Information needed to define a schema.
                                                                                                                                              	SchemaDefinition *SchemaDefinition
                                                                                                                                              }

                                                                                                                                                Contains the configuration information of the Parquet format.

                                                                                                                                                type Pipeline

                                                                                                                                                type Pipeline struct {
                                                                                                                                                
                                                                                                                                                	// The activities that perform transformations on the messages.
                                                                                                                                                	Activities []PipelineActivity
                                                                                                                                                
                                                                                                                                                	// The ARN of the pipeline.
                                                                                                                                                	Arn *string
                                                                                                                                                
                                                                                                                                                	// When the pipeline was created.
                                                                                                                                                	CreationTime *time.Time
                                                                                                                                                
                                                                                                                                                	// The last time the pipeline was updated.
                                                                                                                                                	LastUpdateTime *time.Time
                                                                                                                                                
                                                                                                                                                	// The name of the pipeline.
                                                                                                                                                	Name *string
                                                                                                                                                
                                                                                                                                                	// A summary of information about the pipeline reprocessing.
                                                                                                                                                	ReprocessingSummaries []ReprocessingSummary
                                                                                                                                                }

                                                                                                                                                  Contains information about a pipeline.

                                                                                                                                                  type PipelineActivity

                                                                                                                                                  type PipelineActivity struct {
                                                                                                                                                  
                                                                                                                                                  	// Adds other attributes based on existing attributes in the message.
                                                                                                                                                  	AddAttributes *AddAttributesActivity
                                                                                                                                                  
                                                                                                                                                  	// Determines the source of the messages to be processed.
                                                                                                                                                  	Channel *ChannelActivity
                                                                                                                                                  
                                                                                                                                                  	// Specifies where to store the processed message data.
                                                                                                                                                  	Datastore *DatastoreActivity
                                                                                                                                                  
                                                                                                                                                  	// Adds data from the AWS IoT device registry to your message.
                                                                                                                                                  	DeviceRegistryEnrich *DeviceRegistryEnrichActivity
                                                                                                                                                  
                                                                                                                                                  	// Adds information from the AWS IoT Device Shadow service to a message.
                                                                                                                                                  	DeviceShadowEnrich *DeviceShadowEnrichActivity
                                                                                                                                                  
                                                                                                                                                  	// Filters a message based on its attributes.
                                                                                                                                                  	Filter *FilterActivity
                                                                                                                                                  
                                                                                                                                                  	// Runs a Lambda function to modify the message.
                                                                                                                                                  	Lambda *LambdaActivity
                                                                                                                                                  
                                                                                                                                                  	// Computes an arithmetic expression using the message's attributes and adds it to
                                                                                                                                                  	// the message.
                                                                                                                                                  	Math *MathActivity
                                                                                                                                                  
                                                                                                                                                  	// Removes attributes from a message.
                                                                                                                                                  	RemoveAttributes *RemoveAttributesActivity
                                                                                                                                                  
                                                                                                                                                  	// Creates a new message using only the specified attributes from the original
                                                                                                                                                  	// message.
                                                                                                                                                  	SelectAttributes *SelectAttributesActivity
                                                                                                                                                  }

                                                                                                                                                    An activity that performs a transformation on a message.

                                                                                                                                                    type PipelineSummary

                                                                                                                                                    type PipelineSummary struct {
                                                                                                                                                    
                                                                                                                                                    	// When the pipeline was created.
                                                                                                                                                    	CreationTime *time.Time
                                                                                                                                                    
                                                                                                                                                    	// When the pipeline was last updated.
                                                                                                                                                    	LastUpdateTime *time.Time
                                                                                                                                                    
                                                                                                                                                    	// The name of the pipeline.
                                                                                                                                                    	PipelineName *string
                                                                                                                                                    
                                                                                                                                                    	// A summary of information about the pipeline reprocessing.
                                                                                                                                                    	ReprocessingSummaries []ReprocessingSummary
                                                                                                                                                    }

                                                                                                                                                      A summary of information about a pipeline.

                                                                                                                                                      type QueryFilter

                                                                                                                                                      type QueryFilter struct {
                                                                                                                                                      
                                                                                                                                                      	// Used to limit data to that which has arrived since the last execution of the
                                                                                                                                                      	// action.
                                                                                                                                                      	DeltaTime *DeltaTime
                                                                                                                                                      }

                                                                                                                                                        Information that is used to filter message data, to segregate it according to the timeframe in which it arrives.

                                                                                                                                                        type RemoveAttributesActivity

                                                                                                                                                        type RemoveAttributesActivity struct {
                                                                                                                                                        
                                                                                                                                                        	// A list of 1-50 attributes to remove from the message.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	Attributes []string
                                                                                                                                                        
                                                                                                                                                        	// The name of the removeAttributes activity.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	Name *string
                                                                                                                                                        
                                                                                                                                                        	// The next activity in the pipeline.
                                                                                                                                                        	Next *string
                                                                                                                                                        }

                                                                                                                                                          An activity that removes attributes from a message.

                                                                                                                                                          type ReprocessingStatus

                                                                                                                                                          type ReprocessingStatus string
                                                                                                                                                          const (
                                                                                                                                                          	ReprocessingStatusRunning   ReprocessingStatus = "RUNNING"
                                                                                                                                                          	ReprocessingStatusSucceeded ReprocessingStatus = "SUCCEEDED"
                                                                                                                                                          	ReprocessingStatusCancelled ReprocessingStatus = "CANCELLED"
                                                                                                                                                          	ReprocessingStatusFailed    ReprocessingStatus = "FAILED"
                                                                                                                                                          )

                                                                                                                                                            Enum values for ReprocessingStatus

                                                                                                                                                            func (ReprocessingStatus) Values

                                                                                                                                                              Values returns all known values for ReprocessingStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                              type ReprocessingSummary

                                                                                                                                                              type ReprocessingSummary struct {
                                                                                                                                                              
                                                                                                                                                              	// The time the pipeline reprocessing was created.
                                                                                                                                                              	CreationTime *time.Time
                                                                                                                                                              
                                                                                                                                                              	// The reprocessingId returned by StartPipelineReprocessing.
                                                                                                                                                              	Id *string
                                                                                                                                                              
                                                                                                                                                              	// The status of the pipeline reprocessing.
                                                                                                                                                              	Status ReprocessingStatus
                                                                                                                                                              }

                                                                                                                                                                Information about pipeline reprocessing.

                                                                                                                                                                type ResourceAlreadyExistsException

                                                                                                                                                                type ResourceAlreadyExistsException struct {
                                                                                                                                                                	Message *string
                                                                                                                                                                
                                                                                                                                                                	ResourceId  *string
                                                                                                                                                                	ResourceArn *string
                                                                                                                                                                }

                                                                                                                                                                  A resource with the same name already exists.

                                                                                                                                                                  func (*ResourceAlreadyExistsException) Error

                                                                                                                                                                  func (*ResourceAlreadyExistsException) ErrorCode

                                                                                                                                                                  func (e *ResourceAlreadyExistsException) ErrorCode() string

                                                                                                                                                                  func (*ResourceAlreadyExistsException) ErrorFault

                                                                                                                                                                  func (*ResourceAlreadyExistsException) ErrorMessage

                                                                                                                                                                  func (e *ResourceAlreadyExistsException) ErrorMessage() string

                                                                                                                                                                  type ResourceConfiguration

                                                                                                                                                                  type ResourceConfiguration struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The type of the compute resource used to execute the containerAction. Possible
                                                                                                                                                                  	// values are: ACU_1 (vCPU=4, memory=16 GiB) or ACU_2 (vCPU=8, memory=32 GiB).
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	ComputeType ComputeType
                                                                                                                                                                  
                                                                                                                                                                  	// The size, in GB, of the persistent storage available to the resource instance
                                                                                                                                                                  	// used to execute the containerAction (min: 1, max: 50).
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	VolumeSizeInGB int32
                                                                                                                                                                  }

                                                                                                                                                                    The configuration of the resource used to execute the containerAction.

                                                                                                                                                                    type ResourceNotFoundException

                                                                                                                                                                    type ResourceNotFoundException struct {
                                                                                                                                                                    	Message *string
                                                                                                                                                                    }

                                                                                                                                                                      A resource with the specified name could not be found.

                                                                                                                                                                      func (*ResourceNotFoundException) Error

                                                                                                                                                                      func (e *ResourceNotFoundException) Error() string

                                                                                                                                                                      func (*ResourceNotFoundException) ErrorCode

                                                                                                                                                                      func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                                                                      func (*ResourceNotFoundException) ErrorFault

                                                                                                                                                                      func (*ResourceNotFoundException) ErrorMessage

                                                                                                                                                                      func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                                                                      type RetentionPeriod

                                                                                                                                                                      type RetentionPeriod struct {
                                                                                                                                                                      
                                                                                                                                                                      	// The number of days that message data is kept. The unlimited parameter must be
                                                                                                                                                                      	// false.
                                                                                                                                                                      	NumberOfDays *int32
                                                                                                                                                                      
                                                                                                                                                                      	// If true, message data is kept indefinitely.
                                                                                                                                                                      	Unlimited bool
                                                                                                                                                                      }

                                                                                                                                                                        How long, in days, message data is kept.

                                                                                                                                                                        type S3DestinationConfiguration

                                                                                                                                                                        type S3DestinationConfiguration struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The name of the S3 bucket to which dataset contents are delivered.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	Bucket *string
                                                                                                                                                                        
                                                                                                                                                                        	// The key of the dataset contents object in an S3 bucket. Each object has a key
                                                                                                                                                                        	// that is a unique identifier. Each object has exactly one key. You can create a
                                                                                                                                                                        	// unique key with the following options:
                                                                                                                                                                        	//
                                                                                                                                                                        	// * Use !{iotanalytics:scheduleTime} to
                                                                                                                                                                        	// insert the time of a scheduled SQL query run.
                                                                                                                                                                        	//
                                                                                                                                                                        	// * Use !{iotanalytics:versionId}
                                                                                                                                                                        	// to insert a unique hash that identifies a dataset content.
                                                                                                                                                                        	//
                                                                                                                                                                        	// * Use
                                                                                                                                                                        	// !{iotanalytics:creationTime} to insert the creation time of a dataset
                                                                                                                                                                        	// content.
                                                                                                                                                                        	//
                                                                                                                                                                        	// The following example creates a unique key for a CSV file:
                                                                                                                                                                        	// dataset/mydataset/!{iotanalytics:scheduleTime}/!{iotanalytics:versionId}.csv If
                                                                                                                                                                        	// you don't use !{iotanalytics:versionId} to specify the key, you might get
                                                                                                                                                                        	// duplicate keys. For example, you might have two dataset contents with the same
                                                                                                                                                                        	// scheduleTime but different versionIds. This means that one dataset content
                                                                                                                                                                        	// overwrites the other.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	Key *string
                                                                                                                                                                        
                                                                                                                                                                        	// The ARN of the role that grants AWS IoT Analytics permission to interact with
                                                                                                                                                                        	// your Amazon S3 and AWS Glue resources.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	RoleArn *string
                                                                                                                                                                        
                                                                                                                                                                        	// Configuration information for coordination with AWS Glue, a fully managed
                                                                                                                                                                        	// extract, transform and load (ETL) service.
                                                                                                                                                                        	GlueConfiguration *GlueConfiguration
                                                                                                                                                                        }

                                                                                                                                                                          Configuration information for delivery of dataset contents to Amazon Simple Storage Service (Amazon S3).

                                                                                                                                                                          type Schedule

                                                                                                                                                                          type Schedule struct {
                                                                                                                                                                          
                                                                                                                                                                          	// The expression that defines when to trigger an update. For more information, see
                                                                                                                                                                          	// Schedule Expressions for Rules
                                                                                                                                                                          	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html)
                                                                                                                                                                          	// in the Amazon CloudWatch Events User Guide.
                                                                                                                                                                          	Expression *string
                                                                                                                                                                          }

                                                                                                                                                                            The schedule for when to trigger an update.

                                                                                                                                                                            type SchemaDefinition

                                                                                                                                                                            type SchemaDefinition struct {
                                                                                                                                                                            
                                                                                                                                                                            	// Specifies one or more columns that store your data. Each schema can have up to
                                                                                                                                                                            	// 100 columns. Each column can have up to 100 nested types
                                                                                                                                                                            	Columns []Column
                                                                                                                                                                            }

                                                                                                                                                                              Information needed to define a schema.

                                                                                                                                                                              type SelectAttributesActivity

                                                                                                                                                                              type SelectAttributesActivity struct {
                                                                                                                                                                              
                                                                                                                                                                              	// A list of the attributes to select from the message.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	Attributes []string
                                                                                                                                                                              
                                                                                                                                                                              	// The name of the selectAttributes activity.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	Name *string
                                                                                                                                                                              
                                                                                                                                                                              	// The next activity in the pipeline.
                                                                                                                                                                              	Next *string
                                                                                                                                                                              }

                                                                                                                                                                                Creates a new message using only the specified attributes from the original message.

                                                                                                                                                                                type ServiceManagedChannelS3Storage

                                                                                                                                                                                type ServiceManagedChannelS3Storage struct {
                                                                                                                                                                                }

                                                                                                                                                                                  Use this to store channel data in an S3 bucket managed by AWS IoT Analytics. You cannot change the choice of service-managed or customer-managed S3 storage after the channel is created.

                                                                                                                                                                                  type ServiceManagedChannelS3StorageSummary

                                                                                                                                                                                  type ServiceManagedChannelS3StorageSummary struct {
                                                                                                                                                                                  }

                                                                                                                                                                                    Used to store channel data in an S3 bucket managed by AWS IoT Analytics.

                                                                                                                                                                                    type ServiceManagedDatastoreS3Storage

                                                                                                                                                                                    type ServiceManagedDatastoreS3Storage struct {
                                                                                                                                                                                    }

                                                                                                                                                                                      Use this to store data store data in an S3 bucket managed by AWS IoT Analytics. You cannot change the choice of service-managed or customer-managed S3 storage after the data store is created.

                                                                                                                                                                                      type ServiceManagedDatastoreS3StorageSummary

                                                                                                                                                                                      type ServiceManagedDatastoreS3StorageSummary struct {
                                                                                                                                                                                      }

                                                                                                                                                                                        Used to store data store data in an S3 bucket managed by AWS IoT Analytics.

                                                                                                                                                                                        type ServiceUnavailableException

                                                                                                                                                                                        type ServiceUnavailableException struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          The service is temporarily unavailable.

                                                                                                                                                                                          func (*ServiceUnavailableException) Error

                                                                                                                                                                                          func (*ServiceUnavailableException) ErrorCode

                                                                                                                                                                                          func (e *ServiceUnavailableException) ErrorCode() string

                                                                                                                                                                                          func (*ServiceUnavailableException) ErrorFault

                                                                                                                                                                                          func (*ServiceUnavailableException) ErrorMessage

                                                                                                                                                                                          func (e *ServiceUnavailableException) ErrorMessage() string

                                                                                                                                                                                          type SqlQueryDatasetAction

                                                                                                                                                                                          type SqlQueryDatasetAction struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// A SQL query string.
                                                                                                                                                                                          	//
                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                          	SqlQuery *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Prefilters applied to message data.
                                                                                                                                                                                          	Filters []QueryFilter
                                                                                                                                                                                          }

                                                                                                                                                                                            The SQL query to modify the message.

                                                                                                                                                                                            type Tag

                                                                                                                                                                                            type Tag struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The tag's key.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	Key *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The tag's value.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	Value *string
                                                                                                                                                                                            }

                                                                                                                                                                                              A set of key-value pairs that are used to manage the resource.

                                                                                                                                                                                              type ThrottlingException

                                                                                                                                                                                              type ThrottlingException struct {
                                                                                                                                                                                              	Message *string
                                                                                                                                                                                              }

                                                                                                                                                                                                The request was denied due to request throttling.

                                                                                                                                                                                                func (*ThrottlingException) Error

                                                                                                                                                                                                func (e *ThrottlingException) Error() string

                                                                                                                                                                                                func (*ThrottlingException) ErrorCode

                                                                                                                                                                                                func (e *ThrottlingException) ErrorCode() string

                                                                                                                                                                                                func (*ThrottlingException) ErrorFault

                                                                                                                                                                                                func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                func (*ThrottlingException) ErrorMessage

                                                                                                                                                                                                func (e *ThrottlingException) ErrorMessage() string

                                                                                                                                                                                                type TriggeringDataset

                                                                                                                                                                                                type TriggeringDataset struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// The name of the dataset whose content generation triggers the new dataset
                                                                                                                                                                                                	// content generation.
                                                                                                                                                                                                	//
                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                	Name *string
                                                                                                                                                                                                }

                                                                                                                                                                                                  Information about the dataset whose content generation triggers the new dataset content generation.

                                                                                                                                                                                                  type UnknownUnionMember

                                                                                                                                                                                                  type UnknownUnionMember struct {
                                                                                                                                                                                                  	Tag   string
                                                                                                                                                                                                  	Value []byte
                                                                                                                                                                                                  }

                                                                                                                                                                                                    UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

                                                                                                                                                                                                    type Variable

                                                                                                                                                                                                    type Variable struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The name of the variable.
                                                                                                                                                                                                    	//
                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                    	Name *string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The value of the variable as a structure that specifies a dataset content
                                                                                                                                                                                                    	// version.
                                                                                                                                                                                                    	DatasetContentVersionValue *DatasetContentVersionValue
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The value of the variable as a double (numeric).
                                                                                                                                                                                                    	DoubleValue float64
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The value of the variable as a structure that specifies an output file URI.
                                                                                                                                                                                                    	OutputFileUriValue *OutputFileUriValue
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The value of the variable as a string.
                                                                                                                                                                                                    	StringValue *string
                                                                                                                                                                                                    }

                                                                                                                                                                                                      An instance of a variable to be passed to the containerAction execution. Each variable must have a name and a value given by one of stringValue, datasetContentVersionValue, or outputFileUriValue.

                                                                                                                                                                                                      type VersioningConfiguration

                                                                                                                                                                                                      type VersioningConfiguration struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// How many versions of dataset contents are kept. The unlimited parameter must be
                                                                                                                                                                                                      	// false.
                                                                                                                                                                                                      	MaxVersions *int32
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// If true, unlimited versions of dataset contents are kept.
                                                                                                                                                                                                      	Unlimited bool
                                                                                                                                                                                                      }

                                                                                                                                                                                                        Information about the versioning of dataset contents.