Documentation

Overview

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

    AWS IoT Analytics allows you to collect large amounts of device data, process messages, and store them. You can then query the data and run sophisticated analytics on it. AWS IoT Analytics enables advanced data exploration through integration with Jupyter Notebooks and data visualization through integration with Amazon QuickSight. Traditional analytics and business intelligence tools are designed to process structured data. IoT data often comes from devices that record noisy processes (such as temperature, motion, or sound). As a result the data from these devices can have significant gaps, corrupted messages, and false readings that must be cleaned up before analysis can occur. Also, IoT data is often only meaningful in the context of other data from external sources. AWS IoT Analytics automates the steps required to analyze data from IoT devices. AWS IoT Analytics filters, transforms, and enriches IoT data before storing it in a time-series data store for analysis. You can set up the service to collect only the data you need from your devices, apply mathematical transforms to process the data, and enrich the data with device-specific metadata such as device type and location before storing it. Then, you can analyze your data by running queries using the built-in SQL query engine, or perform more complex analytics and machine learning inference. AWS IoT Analytics includes pre-built models for common IoT use cases so you can answer questions like which devices are about to fail or which customers are at risk of abandoning their wearable devices.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-11-27"
    View Source
    const ServiceID = "IoTAnalytics"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

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

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

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

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

          Types

          type BatchPutMessageInput

          type BatchPutMessageInput struct {
          
          	// The name of the channel where the messages are sent.
          	//
          	// This member is required.
          	ChannelName *string
          
          	// The list of messages to be sent. Each message has the format: { "messageId":
          	// "string", "payload": "string"}. The field names of message payloads (data) that
          	// you send to AWS IoT Analytics:
          	//
          	// * Must contain only alphanumeric characters and
          	// undescores (_). No other special characters are allowed.
          	//
          	// * Must begin with an
          	// alphabetic character or single underscore (_).
          	//
          	// * Cannot contain hyphens (-).
          	//
          	// *
          	// In regular expression terms:
          	// "^[A-Za-z_]([A-Za-z0-9]*|[A-Za-z0-9][A-Za-z0-9_]*)$".
          	//
          	// * Cannot be more than 255
          	// characters.
          	//
          	// * Are case insensitive. (Fields named foo and FOO in the same
          	// payload are considered duplicates.)
          	//
          	// For example, {"temp_01": 29} or
          	// {"_temp_01": 29} are valid, but {"temp-01": 29}, {"01_temp": 29} or
          	// {"__temp_01": 29} are invalid in message payloads.
          	//
          	// This member is required.
          	Messages []types.Message
          }

          type BatchPutMessageOutput

          type BatchPutMessageOutput struct {
          
          	// A list of any errors encountered when sending the messages to the channel.
          	BatchPutMessageErrorEntries []types.BatchPutMessageErrorEntry
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type CancelPipelineReprocessingInput

          type CancelPipelineReprocessingInput struct {
          
          	// The name of pipeline for which data reprocessing is canceled.
          	//
          	// This member is required.
          	PipelineName *string
          
          	// The ID of the reprocessing task (returned by StartPipelineReprocessing).
          	//
          	// This member is required.
          	ReprocessingId *string
          }

          type CancelPipelineReprocessingOutput

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

          type Client

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

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

            func New

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

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

              func NewFromConfig

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

                NewFromConfig returns a new client from the provided config.

                func (*Client) BatchPutMessage

                func (c *Client) BatchPutMessage(ctx context.Context, params *BatchPutMessageInput, optFns ...func(*Options)) (*BatchPutMessageOutput, error)

                  Sends messages to a channel.

                  func (*Client) CancelPipelineReprocessing

                  func (c *Client) CancelPipelineReprocessing(ctx context.Context, params *CancelPipelineReprocessingInput, optFns ...func(*Options)) (*CancelPipelineReprocessingOutput, error)

                    Cancels the reprocessing of data through the pipeline.

                    func (*Client) CreateChannel

                    func (c *Client) CreateChannel(ctx context.Context, params *CreateChannelInput, optFns ...func(*Options)) (*CreateChannelOutput, error)

                      Creates a channel. A channel collects data from an MQTT topic and archives the raw, unprocessed messages before publishing the data to a pipeline.

                      func (*Client) CreateDataset

                      func (c *Client) CreateDataset(ctx context.Context, params *CreateDatasetInput, optFns ...func(*Options)) (*CreateDatasetOutput, error)

                        Creates a dataset. A dataset stores data retrieved from a data store by applying a queryAction (a SQL query) or a containerAction (executing a containerized application). This operation creates the skeleton of a dataset. The dataset can be populated manually by calling CreateDatasetContent or automatically according to a trigger you specify.

                        func (*Client) CreateDatasetContent

                        func (c *Client) CreateDatasetContent(ctx context.Context, params *CreateDatasetContentInput, optFns ...func(*Options)) (*CreateDatasetContentOutput, error)

                          Creates the content of a data set by applying a queryAction (a SQL query) or a containerAction (executing a containerized application).

                          func (*Client) CreateDatastore

                          func (c *Client) CreateDatastore(ctx context.Context, params *CreateDatastoreInput, optFns ...func(*Options)) (*CreateDatastoreOutput, error)

                            Creates a data store, which is a repository for messages.

                            func (*Client) CreatePipeline

                            func (c *Client) CreatePipeline(ctx context.Context, params *CreatePipelineInput, optFns ...func(*Options)) (*CreatePipelineOutput, error)

                              Creates a pipeline. A pipeline consumes messages from a channel and allows you to process the messages before storing them in a data store. You must specify both a channel and a datastore activity and, optionally, as many as 23 additional activities in the pipelineActivities array.

                              func (*Client) DeleteChannel

                              func (c *Client) DeleteChannel(ctx context.Context, params *DeleteChannelInput, optFns ...func(*Options)) (*DeleteChannelOutput, error)

                                Deletes the specified channel.

                                func (*Client) DeleteDataset

                                func (c *Client) DeleteDataset(ctx context.Context, params *DeleteDatasetInput, optFns ...func(*Options)) (*DeleteDatasetOutput, error)

                                  Deletes the specified dataset. You do not have to delete the content of the dataset before you perform this operation.

                                  func (*Client) DeleteDatasetContent

                                  func (c *Client) DeleteDatasetContent(ctx context.Context, params *DeleteDatasetContentInput, optFns ...func(*Options)) (*DeleteDatasetContentOutput, error)

                                    Deletes the content of the specified dataset.

                                    func (*Client) DeleteDatastore

                                    func (c *Client) DeleteDatastore(ctx context.Context, params *DeleteDatastoreInput, optFns ...func(*Options)) (*DeleteDatastoreOutput, error)

                                      Deletes the specified data store.

                                      func (*Client) DeletePipeline

                                      func (c *Client) DeletePipeline(ctx context.Context, params *DeletePipelineInput, optFns ...func(*Options)) (*DeletePipelineOutput, error)

                                        Deletes the specified pipeline.

                                        func (*Client) DescribeChannel

                                        func (c *Client) DescribeChannel(ctx context.Context, params *DescribeChannelInput, optFns ...func(*Options)) (*DescribeChannelOutput, error)

                                          Retrieves information about a channel.

                                          func (*Client) DescribeDataset

                                          func (c *Client) DescribeDataset(ctx context.Context, params *DescribeDatasetInput, optFns ...func(*Options)) (*DescribeDatasetOutput, error)

                                            Retrieves information about a dataset.

                                            func (*Client) DescribeDatastore

                                            func (c *Client) DescribeDatastore(ctx context.Context, params *DescribeDatastoreInput, optFns ...func(*Options)) (*DescribeDatastoreOutput, error)

                                              Retrieves information about a data store.

                                              func (*Client) DescribeLoggingOptions

                                              func (c *Client) DescribeLoggingOptions(ctx context.Context, params *DescribeLoggingOptionsInput, optFns ...func(*Options)) (*DescribeLoggingOptionsOutput, error)

                                                Retrieves the current settings of the AWS IoT Analytics logging options.

                                                func (*Client) DescribePipeline

                                                func (c *Client) DescribePipeline(ctx context.Context, params *DescribePipelineInput, optFns ...func(*Options)) (*DescribePipelineOutput, error)

                                                  Retrieves information about a pipeline.

                                                  func (*Client) GetDatasetContent

                                                  func (c *Client) GetDatasetContent(ctx context.Context, params *GetDatasetContentInput, optFns ...func(*Options)) (*GetDatasetContentOutput, error)

                                                    Retrieves the contents of a data set as presigned URIs.

                                                    func (*Client) ListChannels

                                                    func (c *Client) ListChannels(ctx context.Context, params *ListChannelsInput, optFns ...func(*Options)) (*ListChannelsOutput, error)

                                                      Retrieves a list of channels.

                                                      func (*Client) ListDatasetContents

                                                      func (c *Client) ListDatasetContents(ctx context.Context, params *ListDatasetContentsInput, optFns ...func(*Options)) (*ListDatasetContentsOutput, error)

                                                        Lists information about data set contents that have been created.

                                                        func (*Client) ListDatasets

                                                        func (c *Client) ListDatasets(ctx context.Context, params *ListDatasetsInput, optFns ...func(*Options)) (*ListDatasetsOutput, error)

                                                          Retrieves information about data sets.

                                                          func (*Client) ListDatastores

                                                          func (c *Client) ListDatastores(ctx context.Context, params *ListDatastoresInput, optFns ...func(*Options)) (*ListDatastoresOutput, error)

                                                            Retrieves a list of data stores.

                                                            func (*Client) ListPipelines

                                                            func (c *Client) ListPipelines(ctx context.Context, params *ListPipelinesInput, optFns ...func(*Options)) (*ListPipelinesOutput, error)

                                                              Retrieves a list of pipelines.

                                                              func (*Client) ListTagsForResource

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

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

                                                                func (*Client) PutLoggingOptions

                                                                func (c *Client) PutLoggingOptions(ctx context.Context, params *PutLoggingOptionsInput, optFns ...func(*Options)) (*PutLoggingOptionsOutput, error)

                                                                  Sets or updates the AWS IoT Analytics logging options. If you update the value of any loggingOptions field, it takes up to one minute for the change to take effect. Also, if you change the policy attached to the role you specified in the roleArn field (for example, to correct an invalid policy), it takes up to five minutes for that change to take effect.

                                                                  func (*Client) RunPipelineActivity

                                                                  func (c *Client) RunPipelineActivity(ctx context.Context, params *RunPipelineActivityInput, optFns ...func(*Options)) (*RunPipelineActivityOutput, error)

                                                                    Simulates the results of running a pipeline activity on a message payload.

                                                                    func (*Client) SampleChannelData

                                                                    func (c *Client) SampleChannelData(ctx context.Context, params *SampleChannelDataInput, optFns ...func(*Options)) (*SampleChannelDataOutput, error)

                                                                      Retrieves a sample of messages from the specified channel ingested during the specified timeframe. Up to 10 messages can be retrieved.

                                                                      func (*Client) StartPipelineReprocessing

                                                                      func (c *Client) StartPipelineReprocessing(ctx context.Context, params *StartPipelineReprocessingInput, optFns ...func(*Options)) (*StartPipelineReprocessingOutput, error)

                                                                        Starts the reprocessing of raw message data through the pipeline.

                                                                        func (*Client) TagResource

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

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

                                                                          func (*Client) UntagResource

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

                                                                            Removes the given tags (metadata) from the resource.

                                                                            func (*Client) UpdateChannel

                                                                            func (c *Client) UpdateChannel(ctx context.Context, params *UpdateChannelInput, optFns ...func(*Options)) (*UpdateChannelOutput, error)

                                                                              Updates the settings of a channel.

                                                                              func (*Client) UpdateDataset

                                                                              func (c *Client) UpdateDataset(ctx context.Context, params *UpdateDatasetInput, optFns ...func(*Options)) (*UpdateDatasetOutput, error)

                                                                                Updates the settings of a data set.

                                                                                func (*Client) UpdateDatastore

                                                                                func (c *Client) UpdateDatastore(ctx context.Context, params *UpdateDatastoreInput, optFns ...func(*Options)) (*UpdateDatastoreOutput, error)

                                                                                  Updates the settings of a data store.

                                                                                  func (*Client) UpdatePipeline

                                                                                  func (c *Client) UpdatePipeline(ctx context.Context, params *UpdatePipelineInput, optFns ...func(*Options)) (*UpdatePipelineOutput, error)

                                                                                    Updates the settings of a pipeline. You must specify both a channel and a datastore activity and, optionally, as many as 23 additional activities in the pipelineActivities array.

                                                                                    type CreateChannelInput

                                                                                    type CreateChannelInput struct {
                                                                                    
                                                                                    	// The name of the channel.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	ChannelName *string
                                                                                    
                                                                                    	// 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.
                                                                                    	ChannelStorage *types.ChannelStorage
                                                                                    
                                                                                    	// How long, in days, message data is kept for the channel. When customerManagedS3
                                                                                    	// storage is selected, this parameter is ignored.
                                                                                    	RetentionPeriod *types.RetentionPeriod
                                                                                    
                                                                                    	// Metadata which can be used to manage the channel.
                                                                                    	Tags []types.Tag
                                                                                    }

                                                                                    type CreateChannelOutput

                                                                                    type CreateChannelOutput struct {
                                                                                    
                                                                                    	// The ARN of the channel.
                                                                                    	ChannelArn *string
                                                                                    
                                                                                    	// The name of the channel.
                                                                                    	ChannelName *string
                                                                                    
                                                                                    	// How long, in days, message data is kept for the channel.
                                                                                    	RetentionPeriod *types.RetentionPeriod
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type CreateDatasetContentInput

                                                                                    type CreateDatasetContentInput struct {
                                                                                    
                                                                                    	// The name of the dataset.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatasetName *string
                                                                                    
                                                                                    	// The version ID of the dataset content. To specify versionId for a dataset
                                                                                    	// content, the dataset must use a DeltaTimer
                                                                                    	// (https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html)
                                                                                    	// filter.
                                                                                    	VersionId *string
                                                                                    }

                                                                                    type CreateDatasetContentOutput

                                                                                    type CreateDatasetContentOutput struct {
                                                                                    
                                                                                    	// The version ID of the dataset contents that are being created.
                                                                                    	VersionId *string
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type CreateDatasetInput

                                                                                    type CreateDatasetInput struct {
                                                                                    
                                                                                    	// A list of actions that create the data set contents.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Actions []types.DatasetAction
                                                                                    
                                                                                    	// The name of the data set.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatasetName *string
                                                                                    
                                                                                    	// When dataset contents are created, they are delivered to destinations specified
                                                                                    	// here.
                                                                                    	ContentDeliveryRules []types.DatasetContentDeliveryRule
                                                                                    
                                                                                    	// 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 []types.LateDataRule
                                                                                    
                                                                                    	// Optional. How long, in days, versions of dataset contents are kept for the
                                                                                    	// dataset. If not specified or set to null, versions of dataset contents are
                                                                                    	// retained for at most 90 days. The number of versions of dataset contents
                                                                                    	// retained is determined by the versioningConfiguration 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.
                                                                                    	RetentionPeriod *types.RetentionPeriod
                                                                                    
                                                                                    	// Metadata which can be used to manage the data set.
                                                                                    	Tags []types.Tag
                                                                                    
                                                                                    	// A list of triggers. A trigger causes data set contents to be populated at a
                                                                                    	// specified time interval or when another data set's contents are created. The
                                                                                    	// list of triggers can be empty or contain up to five DataSetTrigger objects.
                                                                                    	Triggers []types.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 *types.VersioningConfiguration
                                                                                    }

                                                                                    type CreateDatasetOutput

                                                                                    type CreateDatasetOutput struct {
                                                                                    
                                                                                    	// The ARN of the dataset.
                                                                                    	DatasetArn *string
                                                                                    
                                                                                    	// The name of the dataset.
                                                                                    	DatasetName *string
                                                                                    
                                                                                    	// How long, in days, dataset contents are kept for the dataset.
                                                                                    	RetentionPeriod *types.RetentionPeriod
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type CreateDatastoreInput

                                                                                    type CreateDatastoreInput struct {
                                                                                    
                                                                                    	// The name of the data store.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatastoreName *string
                                                                                    
                                                                                    	// 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.
                                                                                    	DatastoreStorage types.DatastoreStorage
                                                                                    
                                                                                    	// 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 *types.FileFormatConfiguration
                                                                                    
                                                                                    	// How long, in days, message data is kept for the data store. When
                                                                                    	// customerManagedS3 storage is selected, this parameter is ignored.
                                                                                    	RetentionPeriod *types.RetentionPeriod
                                                                                    
                                                                                    	// Metadata which can be used to manage the data store.
                                                                                    	Tags []types.Tag
                                                                                    }

                                                                                    type CreateDatastoreOutput

                                                                                    type CreateDatastoreOutput struct {
                                                                                    
                                                                                    	// The ARN of the data store.
                                                                                    	DatastoreArn *string
                                                                                    
                                                                                    	// The name of the data store.
                                                                                    	DatastoreName *string
                                                                                    
                                                                                    	// How long, in days, message data is kept for the data store.
                                                                                    	RetentionPeriod *types.RetentionPeriod
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type CreatePipelineInput

                                                                                    type CreatePipelineInput struct {
                                                                                    
                                                                                    	// A list of PipelineActivity objects. Activities perform transformations on your
                                                                                    	// messages, such as removing, renaming or adding message attributes; filtering
                                                                                    	// messages based on attribute values; invoking your Lambda functions on messages
                                                                                    	// for advanced processing; or performing mathematical transformations to normalize
                                                                                    	// device data. The list can be 2-25 PipelineActivity objects and must contain both
                                                                                    	// a channel and a datastore activity. Each entry in the list must contain only one
                                                                                    	// activity. For example: pipelineActivities = [ { "channel": { ... } }, {
                                                                                    	// "lambda": { ... } }, ... ]
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	PipelineActivities []types.PipelineActivity
                                                                                    
                                                                                    	// The name of the pipeline.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	PipelineName *string
                                                                                    
                                                                                    	// Metadata which can be used to manage the pipeline.
                                                                                    	Tags []types.Tag
                                                                                    }

                                                                                    type CreatePipelineOutput

                                                                                    type CreatePipelineOutput struct {
                                                                                    
                                                                                    	// The ARN of the pipeline.
                                                                                    	PipelineArn *string
                                                                                    
                                                                                    	// The name of the pipeline.
                                                                                    	PipelineName *string
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type DeleteChannelInput

                                                                                    type DeleteChannelInput struct {
                                                                                    
                                                                                    	// The name of the channel to delete.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	ChannelName *string
                                                                                    }

                                                                                    type DeleteChannelOutput

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

                                                                                    type DeleteDatasetContentInput

                                                                                    type DeleteDatasetContentInput struct {
                                                                                    
                                                                                    	// The name of the dataset whose content is deleted.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatasetName *string
                                                                                    
                                                                                    	// The version of the dataset whose content is deleted. You can also use the
                                                                                    	// strings "$LATEST" or "$LATEST_SUCCEEDED" to delete the latest or latest
                                                                                    	// successfully completed data set. If not specified, "$LATEST_SUCCEEDED" is the
                                                                                    	// default.
                                                                                    	VersionId *string
                                                                                    }

                                                                                    type DeleteDatasetContentOutput

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

                                                                                    type DeleteDatasetInput

                                                                                    type DeleteDatasetInput struct {
                                                                                    
                                                                                    	// The name of the data set to delete.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatasetName *string
                                                                                    }

                                                                                    type DeleteDatasetOutput

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

                                                                                    type DeleteDatastoreInput

                                                                                    type DeleteDatastoreInput struct {
                                                                                    
                                                                                    	// The name of the data store to delete.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatastoreName *string
                                                                                    }

                                                                                    type DeleteDatastoreOutput

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

                                                                                    type DeletePipelineInput

                                                                                    type DeletePipelineInput struct {
                                                                                    
                                                                                    	// The name of the pipeline to delete.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	PipelineName *string
                                                                                    }

                                                                                    type DeletePipelineOutput

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

                                                                                    type DescribeChannelInput

                                                                                    type DescribeChannelInput struct {
                                                                                    
                                                                                    	// The name of the channel whose information is retrieved.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	ChannelName *string
                                                                                    
                                                                                    	// If true, additional statistical information about the channel is included in the
                                                                                    	// response. This feature cannot be used with a channel whose S3 storage is
                                                                                    	// customer-managed.
                                                                                    	IncludeStatistics bool
                                                                                    }

                                                                                    type DescribeChannelOutput

                                                                                    type DescribeChannelOutput struct {
                                                                                    
                                                                                    	// An object that contains information about the channel.
                                                                                    	Channel *types.Channel
                                                                                    
                                                                                    	// Statistics about the channel. Included if the includeStatistics parameter is set
                                                                                    	// to true in the request.
                                                                                    	Statistics *types.ChannelStatistics
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type DescribeDatasetInput

                                                                                    type DescribeDatasetInput struct {
                                                                                    
                                                                                    	// The name of the data set whose information is retrieved.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatasetName *string
                                                                                    }

                                                                                    type DescribeDatasetOutput

                                                                                    type DescribeDatasetOutput struct {
                                                                                    
                                                                                    	// An object that contains information about the data set.
                                                                                    	Dataset *types.Dataset
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type DescribeDatastoreInput

                                                                                    type DescribeDatastoreInput struct {
                                                                                    
                                                                                    	// The name of the data store
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DatastoreName *string
                                                                                    
                                                                                    	// If true, additional statistical information about the data store is included in
                                                                                    	// the response. This feature cannot be used with a data store whose S3 storage is
                                                                                    	// customer-managed.
                                                                                    	IncludeStatistics bool
                                                                                    }

                                                                                    type DescribeDatastoreOutput

                                                                                    type DescribeDatastoreOutput struct {
                                                                                    
                                                                                    	// Information about the data store.
                                                                                    	Datastore *types.Datastore
                                                                                    
                                                                                    	// Additional statistical information about the data store. Included if the
                                                                                    	// includeStatistics parameter is set to true in the request.
                                                                                    	Statistics *types.DatastoreStatistics
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type DescribeLoggingOptionsInput

                                                                                    type DescribeLoggingOptionsInput struct {
                                                                                    }

                                                                                    type DescribeLoggingOptionsOutput

                                                                                    type DescribeLoggingOptionsOutput struct {
                                                                                    
                                                                                    	// The current settings of the AWS IoT Analytics logging options.
                                                                                    	LoggingOptions *types.LoggingOptions
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type DescribePipelineInput

                                                                                    type DescribePipelineInput struct {
                                                                                    
                                                                                    	// The name of the pipeline whose information is retrieved.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	PipelineName *string
                                                                                    }

                                                                                    type DescribePipelineOutput

                                                                                    type DescribePipelineOutput struct {
                                                                                    
                                                                                    	// A Pipeline object that contains information about the pipeline.
                                                                                    	Pipeline *types.Pipeline
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type EndpointResolver

                                                                                    type EndpointResolver interface {
                                                                                    	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                    }

                                                                                      EndpointResolver interface for resolving service endpoints.

                                                                                      func EndpointResolverFromURL

                                                                                      func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                        EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                        type EndpointResolverFunc

                                                                                        type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                          EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                          func (EndpointResolverFunc) ResolveEndpoint

                                                                                          func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                          type EndpointResolverOptions

                                                                                          type EndpointResolverOptions = internalendpoints.Options

                                                                                            EndpointResolverOptions is the service endpoint resolver options

                                                                                            type GetDatasetContentInput

                                                                                            type GetDatasetContentInput struct {
                                                                                            
                                                                                            	// The name of the data set whose contents are retrieved.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	DatasetName *string
                                                                                            
                                                                                            	// The version of the data set whose contents are retrieved. You can also use the
                                                                                            	// strings "$LATEST" or "$LATEST_SUCCEEDED" to retrieve the contents of the latest
                                                                                            	// or latest successfully completed data set. If not specified, "$LATEST_SUCCEEDED"
                                                                                            	// is the default.
                                                                                            	VersionId *string
                                                                                            }

                                                                                            type GetDatasetContentOutput

                                                                                            type GetDatasetContentOutput struct {
                                                                                            
                                                                                            	// A list of DatasetEntry objects.
                                                                                            	Entries []types.DatasetEntry
                                                                                            
                                                                                            	// The status of the data set content.
                                                                                            	Status *types.DatasetContentStatus
                                                                                            
                                                                                            	// The time when the request was made.
                                                                                            	Timestamp *time.Time
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type HTTPClient

                                                                                            type HTTPClient interface {
                                                                                            	Do(*http.Request) (*http.Response, error)
                                                                                            }

                                                                                            type HTTPSignerV4

                                                                                            type HTTPSignerV4 interface {
                                                                                            	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                            }

                                                                                            type ListChannelsAPIClient

                                                                                            type ListChannelsAPIClient interface {
                                                                                            	ListChannels(context.Context, *ListChannelsInput, ...func(*Options)) (*ListChannelsOutput, error)
                                                                                            }

                                                                                              ListChannelsAPIClient is a client that implements the ListChannels operation.

                                                                                              type ListChannelsInput

                                                                                              type ListChannelsInput struct {
                                                                                              
                                                                                              	// The maximum number of results to return in this request. The default value is
                                                                                              	// 100.
                                                                                              	MaxResults *int32
                                                                                              
                                                                                              	// The token for the next set of results.
                                                                                              	NextToken *string
                                                                                              }

                                                                                              type ListChannelsOutput

                                                                                              type ListChannelsOutput struct {
                                                                                              
                                                                                              	// A list of ChannelSummary objects.
                                                                                              	ChannelSummaries []types.ChannelSummary
                                                                                              
                                                                                              	// The token to retrieve the next set of results, or null if there are no more
                                                                                              	// results.
                                                                                              	NextToken *string
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                              type ListChannelsPaginator

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

                                                                                                ListChannelsPaginator is a paginator for ListChannels

                                                                                                func NewListChannelsPaginator

                                                                                                func NewListChannelsPaginator(client ListChannelsAPIClient, params *ListChannelsInput, optFns ...func(*ListChannelsPaginatorOptions)) *ListChannelsPaginator

                                                                                                  NewListChannelsPaginator returns a new ListChannelsPaginator

                                                                                                  func (*ListChannelsPaginator) HasMorePages

                                                                                                  func (p *ListChannelsPaginator) HasMorePages() bool

                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                    func (*ListChannelsPaginator) NextPage

                                                                                                    func (p *ListChannelsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListChannelsOutput, error)

                                                                                                      NextPage retrieves the next ListChannels page.

                                                                                                      type ListChannelsPaginatorOptions

                                                                                                      type ListChannelsPaginatorOptions struct {
                                                                                                      	// The maximum number of results to return in this request. The default value is
                                                                                                      	// 100.
                                                                                                      	Limit int32
                                                                                                      
                                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                      	// that matches the most recent token provided to the service.
                                                                                                      	StopOnDuplicateToken bool
                                                                                                      }

                                                                                                        ListChannelsPaginatorOptions is the paginator options for ListChannels

                                                                                                        type ListDatasetContentsAPIClient

                                                                                                        type ListDatasetContentsAPIClient interface {
                                                                                                        	ListDatasetContents(context.Context, *ListDatasetContentsInput, ...func(*Options)) (*ListDatasetContentsOutput, error)
                                                                                                        }

                                                                                                          ListDatasetContentsAPIClient is a client that implements the ListDatasetContents operation.

                                                                                                          type ListDatasetContentsInput

                                                                                                          type ListDatasetContentsInput struct {
                                                                                                          
                                                                                                          	// The name of the data set whose contents information you want to list.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	DatasetName *string
                                                                                                          
                                                                                                          	// The maximum number of results to return in this request.
                                                                                                          	MaxResults *int32
                                                                                                          
                                                                                                          	// The token for the next set of results.
                                                                                                          	NextToken *string
                                                                                                          
                                                                                                          	// A filter to limit results to those data set contents whose creation is scheduled
                                                                                                          	// before the given time. See the field triggers.schedule in the CreateDataset
                                                                                                          	// request. (timestamp)
                                                                                                          	ScheduledBefore *time.Time
                                                                                                          
                                                                                                          	// A filter to limit results to those data set contents whose creation is scheduled
                                                                                                          	// on or after the given time. See the field triggers.schedule in the CreateDataset
                                                                                                          	// request. (timestamp)
                                                                                                          	ScheduledOnOrAfter *time.Time
                                                                                                          }

                                                                                                          type ListDatasetContentsOutput

                                                                                                          type ListDatasetContentsOutput struct {
                                                                                                          
                                                                                                          	// Summary information about data set contents that have been created.
                                                                                                          	DatasetContentSummaries []types.DatasetContentSummary
                                                                                                          
                                                                                                          	// The token to retrieve the next set of results, or null if there are no more
                                                                                                          	// results.
                                                                                                          	NextToken *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type ListDatasetContentsPaginator

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

                                                                                                            ListDatasetContentsPaginator is a paginator for ListDatasetContents

                                                                                                            func NewListDatasetContentsPaginator

                                                                                                            func NewListDatasetContentsPaginator(client ListDatasetContentsAPIClient, params *ListDatasetContentsInput, optFns ...func(*ListDatasetContentsPaginatorOptions)) *ListDatasetContentsPaginator

                                                                                                              NewListDatasetContentsPaginator returns a new ListDatasetContentsPaginator

                                                                                                              func (*ListDatasetContentsPaginator) HasMorePages

                                                                                                              func (p *ListDatasetContentsPaginator) HasMorePages() bool

                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                func (*ListDatasetContentsPaginator) NextPage

                                                                                                                func (p *ListDatasetContentsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetContentsOutput, error)

                                                                                                                  NextPage retrieves the next ListDatasetContents page.

                                                                                                                  type ListDatasetContentsPaginatorOptions

                                                                                                                  type ListDatasetContentsPaginatorOptions struct {
                                                                                                                  	// The maximum number of results to return in this request.
                                                                                                                  	Limit int32
                                                                                                                  
                                                                                                                  	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                  	// that matches the most recent token provided to the service.
                                                                                                                  	StopOnDuplicateToken bool
                                                                                                                  }

                                                                                                                    ListDatasetContentsPaginatorOptions is the paginator options for ListDatasetContents

                                                                                                                    type ListDatasetsAPIClient

                                                                                                                    type ListDatasetsAPIClient interface {
                                                                                                                    	ListDatasets(context.Context, *ListDatasetsInput, ...func(*Options)) (*ListDatasetsOutput, error)
                                                                                                                    }

                                                                                                                      ListDatasetsAPIClient is a client that implements the ListDatasets operation.

                                                                                                                      type ListDatasetsInput

                                                                                                                      type ListDatasetsInput struct {
                                                                                                                      
                                                                                                                      	// The maximum number of results to return in this request. The default value is
                                                                                                                      	// 100.
                                                                                                                      	MaxResults *int32
                                                                                                                      
                                                                                                                      	// The token for the next set of results.
                                                                                                                      	NextToken *string
                                                                                                                      }

                                                                                                                      type ListDatasetsOutput

                                                                                                                      type ListDatasetsOutput struct {
                                                                                                                      
                                                                                                                      	// A list of DatasetSummary objects.
                                                                                                                      	DatasetSummaries []types.DatasetSummary
                                                                                                                      
                                                                                                                      	// The token to retrieve the next set of results, or null if there are no more
                                                                                                                      	// results.
                                                                                                                      	NextToken *string
                                                                                                                      
                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                      }

                                                                                                                      type ListDatasetsPaginator

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

                                                                                                                        ListDatasetsPaginator is a paginator for ListDatasets

                                                                                                                        func NewListDatasetsPaginator

                                                                                                                        func NewListDatasetsPaginator(client ListDatasetsAPIClient, params *ListDatasetsInput, optFns ...func(*ListDatasetsPaginatorOptions)) *ListDatasetsPaginator

                                                                                                                          NewListDatasetsPaginator returns a new ListDatasetsPaginator

                                                                                                                          func (*ListDatasetsPaginator) HasMorePages

                                                                                                                          func (p *ListDatasetsPaginator) HasMorePages() bool

                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                            func (*ListDatasetsPaginator) NextPage

                                                                                                                            func (p *ListDatasetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatasetsOutput, error)

                                                                                                                              NextPage retrieves the next ListDatasets page.

                                                                                                                              type ListDatasetsPaginatorOptions

                                                                                                                              type ListDatasetsPaginatorOptions struct {
                                                                                                                              	// The maximum number of results to return in this request. The default value is
                                                                                                                              	// 100.
                                                                                                                              	Limit int32
                                                                                                                              
                                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                                              	StopOnDuplicateToken bool
                                                                                                                              }

                                                                                                                                ListDatasetsPaginatorOptions is the paginator options for ListDatasets

                                                                                                                                type ListDatastoresAPIClient

                                                                                                                                type ListDatastoresAPIClient interface {
                                                                                                                                	ListDatastores(context.Context, *ListDatastoresInput, ...func(*Options)) (*ListDatastoresOutput, error)
                                                                                                                                }

                                                                                                                                  ListDatastoresAPIClient is a client that implements the ListDatastores operation.

                                                                                                                                  type ListDatastoresInput

                                                                                                                                  type ListDatastoresInput struct {
                                                                                                                                  
                                                                                                                                  	// The maximum number of results to return in this request. The default value is
                                                                                                                                  	// 100.
                                                                                                                                  	MaxResults *int32
                                                                                                                                  
                                                                                                                                  	// The token for the next set of results.
                                                                                                                                  	NextToken *string
                                                                                                                                  }

                                                                                                                                  type ListDatastoresOutput

                                                                                                                                  type ListDatastoresOutput struct {
                                                                                                                                  
                                                                                                                                  	// A list of DatastoreSummary objects.
                                                                                                                                  	DatastoreSummaries []types.DatastoreSummary
                                                                                                                                  
                                                                                                                                  	// The token to retrieve the next set of results, or null if there are no more
                                                                                                                                  	// results.
                                                                                                                                  	NextToken *string
                                                                                                                                  
                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                  }

                                                                                                                                  type ListDatastoresPaginator

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

                                                                                                                                    ListDatastoresPaginator is a paginator for ListDatastores

                                                                                                                                    func NewListDatastoresPaginator

                                                                                                                                    func NewListDatastoresPaginator(client ListDatastoresAPIClient, params *ListDatastoresInput, optFns ...func(*ListDatastoresPaginatorOptions)) *ListDatastoresPaginator

                                                                                                                                      NewListDatastoresPaginator returns a new ListDatastoresPaginator

                                                                                                                                      func (*ListDatastoresPaginator) HasMorePages

                                                                                                                                      func (p *ListDatastoresPaginator) HasMorePages() bool

                                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                        func (*ListDatastoresPaginator) NextPage

                                                                                                                                        func (p *ListDatastoresPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDatastoresOutput, error)

                                                                                                                                          NextPage retrieves the next ListDatastores page.

                                                                                                                                          type ListDatastoresPaginatorOptions

                                                                                                                                          type ListDatastoresPaginatorOptions struct {
                                                                                                                                          	// The maximum number of results to return in this request. The default value is
                                                                                                                                          	// 100.
                                                                                                                                          	Limit int32
                                                                                                                                          
                                                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                                                          	StopOnDuplicateToken bool
                                                                                                                                          }

                                                                                                                                            ListDatastoresPaginatorOptions is the paginator options for ListDatastores

                                                                                                                                            type ListPipelinesAPIClient

                                                                                                                                            type ListPipelinesAPIClient interface {
                                                                                                                                            	ListPipelines(context.Context, *ListPipelinesInput, ...func(*Options)) (*ListPipelinesOutput, error)
                                                                                                                                            }

                                                                                                                                              ListPipelinesAPIClient is a client that implements the ListPipelines operation.

                                                                                                                                              type ListPipelinesInput

                                                                                                                                              type ListPipelinesInput struct {
                                                                                                                                              
                                                                                                                                              	// The maximum number of results to return in this request. The default value is
                                                                                                                                              	// 100.
                                                                                                                                              	MaxResults *int32
                                                                                                                                              
                                                                                                                                              	// The token for the next set of results.
                                                                                                                                              	NextToken *string
                                                                                                                                              }

                                                                                                                                              type ListPipelinesOutput

                                                                                                                                              type ListPipelinesOutput struct {
                                                                                                                                              
                                                                                                                                              	// The token to retrieve the next set of results, or null if there are no more
                                                                                                                                              	// results.
                                                                                                                                              	NextToken *string
                                                                                                                                              
                                                                                                                                              	// A list of PipelineSummary objects.
                                                                                                                                              	PipelineSummaries []types.PipelineSummary
                                                                                                                                              
                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                              }

                                                                                                                                              type ListPipelinesPaginator

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

                                                                                                                                                ListPipelinesPaginator is a paginator for ListPipelines

                                                                                                                                                func NewListPipelinesPaginator

                                                                                                                                                func NewListPipelinesPaginator(client ListPipelinesAPIClient, params *ListPipelinesInput, optFns ...func(*ListPipelinesPaginatorOptions)) *ListPipelinesPaginator

                                                                                                                                                  NewListPipelinesPaginator returns a new ListPipelinesPaginator

                                                                                                                                                  func (*ListPipelinesPaginator) HasMorePages

                                                                                                                                                  func (p *ListPipelinesPaginator) HasMorePages() bool

                                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                    func (*ListPipelinesPaginator) NextPage

                                                                                                                                                    func (p *ListPipelinesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPipelinesOutput, error)

                                                                                                                                                      NextPage retrieves the next ListPipelines page.

                                                                                                                                                      type ListPipelinesPaginatorOptions

                                                                                                                                                      type ListPipelinesPaginatorOptions struct {
                                                                                                                                                      	// The maximum number of results to return in this request. The default value is
                                                                                                                                                      	// 100.
                                                                                                                                                      	Limit int32
                                                                                                                                                      
                                                                                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                      	// that matches the most recent token provided to the service.
                                                                                                                                                      	StopOnDuplicateToken bool
                                                                                                                                                      }

                                                                                                                                                        ListPipelinesPaginatorOptions is the paginator options for ListPipelines

                                                                                                                                                        type ListTagsForResourceInput

                                                                                                                                                        type ListTagsForResourceInput struct {
                                                                                                                                                        
                                                                                                                                                        	// The ARN of the resource whose tags you want to list.
                                                                                                                                                        	//
                                                                                                                                                        	// This member is required.
                                                                                                                                                        	ResourceArn *string
                                                                                                                                                        }

                                                                                                                                                        type ListTagsForResourceOutput

                                                                                                                                                        type ListTagsForResourceOutput struct {
                                                                                                                                                        
                                                                                                                                                        	// The tags (metadata) that you have assigned to the resource.
                                                                                                                                                        	Tags []types.Tag
                                                                                                                                                        
                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                        }

                                                                                                                                                        type Options

                                                                                                                                                        type Options struct {
                                                                                                                                                        	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                        	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                        	// modify this list for per operation behavior.
                                                                                                                                                        	APIOptions []func(*middleware.Stack) error
                                                                                                                                                        
                                                                                                                                                        	// Configures the events that will be sent to the configured logger.
                                                                                                                                                        	ClientLogMode aws.ClientLogMode
                                                                                                                                                        
                                                                                                                                                        	// The credentials object to use when signing requests.
                                                                                                                                                        	Credentials aws.CredentialsProvider
                                                                                                                                                        
                                                                                                                                                        	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                        	EndpointOptions EndpointResolverOptions
                                                                                                                                                        
                                                                                                                                                        	// The service endpoint resolver.
                                                                                                                                                        	EndpointResolver EndpointResolver
                                                                                                                                                        
                                                                                                                                                        	// Signature Version 4 (SigV4) Signer
                                                                                                                                                        	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                        
                                                                                                                                                        	// The logger writer interface to write logging messages to.
                                                                                                                                                        	Logger logging.Logger
                                                                                                                                                        
                                                                                                                                                        	// The region to send requests to. (Required)
                                                                                                                                                        	Region string
                                                                                                                                                        
                                                                                                                                                        	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                        	// failures. When nil the API client will use a default retryer.
                                                                                                                                                        	Retryer aws.Retryer
                                                                                                                                                        
                                                                                                                                                        	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                        	// implementation if nil.
                                                                                                                                                        	HTTPClient HTTPClient
                                                                                                                                                        }

                                                                                                                                                        func (Options) Copy

                                                                                                                                                        func (o Options) Copy() Options

                                                                                                                                                          Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                          type PutLoggingOptionsInput

                                                                                                                                                          type PutLoggingOptionsInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The new values of the AWS IoT Analytics logging options.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	LoggingOptions *types.LoggingOptions
                                                                                                                                                          }

                                                                                                                                                          type PutLoggingOptionsOutput

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

                                                                                                                                                          type ResolveEndpoint

                                                                                                                                                          type ResolveEndpoint struct {
                                                                                                                                                          	Resolver EndpointResolver
                                                                                                                                                          	Options  EndpointResolverOptions
                                                                                                                                                          }

                                                                                                                                                          func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                          func (*ResolveEndpoint) ID

                                                                                                                                                          func (*ResolveEndpoint) ID() string

                                                                                                                                                          type RunPipelineActivityInput

                                                                                                                                                          type RunPipelineActivityInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The sample message payloads on which the pipeline activity is run.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	Payloads [][]byte
                                                                                                                                                          
                                                                                                                                                          	// The pipeline activity that is run. This must not be a channel activity or a
                                                                                                                                                          	// datastore activity because these activities are used in a pipeline only to load
                                                                                                                                                          	// the original message and to store the (possibly) transformed message. If a
                                                                                                                                                          	// lambda activity is specified, only short-running Lambda functions (those with a
                                                                                                                                                          	// timeout of less than 30 seconds or less) can be used.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	PipelineActivity *types.PipelineActivity
                                                                                                                                                          }

                                                                                                                                                          type RunPipelineActivityOutput

                                                                                                                                                          type RunPipelineActivityOutput struct {
                                                                                                                                                          
                                                                                                                                                          	// In case the pipeline activity fails, the log message that is generated.
                                                                                                                                                          	LogResult *string
                                                                                                                                                          
                                                                                                                                                          	// The enriched or transformed sample message payloads as base64-encoded strings.
                                                                                                                                                          	// (The results of running the pipeline activity on each input sample message
                                                                                                                                                          	// payload, encoded in base64.)
                                                                                                                                                          	Payloads [][]byte
                                                                                                                                                          
                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                          }

                                                                                                                                                          type SampleChannelDataInput

                                                                                                                                                          type SampleChannelDataInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The name of the channel whose message samples are retrieved.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	ChannelName *string
                                                                                                                                                          
                                                                                                                                                          	// The end of the time window from which sample messages are retrieved.
                                                                                                                                                          	EndTime *time.Time
                                                                                                                                                          
                                                                                                                                                          	// The number of sample messages to be retrieved. The limit is 10. The default is
                                                                                                                                                          	// also 10.
                                                                                                                                                          	MaxMessages *int32
                                                                                                                                                          
                                                                                                                                                          	// The start of the time window from which sample messages are retrieved.
                                                                                                                                                          	StartTime *time.Time
                                                                                                                                                          }

                                                                                                                                                          type SampleChannelDataOutput

                                                                                                                                                          type SampleChannelDataOutput struct {
                                                                                                                                                          
                                                                                                                                                          	// The list of message samples. Each sample message is returned as a base64-encoded
                                                                                                                                                          	// string.
                                                                                                                                                          	Payloads [][]byte
                                                                                                                                                          
                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                          }

                                                                                                                                                          type StartPipelineReprocessingInput

                                                                                                                                                          type StartPipelineReprocessingInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The name of the pipeline on which to start reprocessing.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	PipelineName *string
                                                                                                                                                          
                                                                                                                                                          	// Specifies one or more sets of channel messages that you want to reprocess. If
                                                                                                                                                          	// you use the channelMessages object, you must not specify a value for startTime
                                                                                                                                                          	// and endTime.
                                                                                                                                                          	ChannelMessages *types.ChannelMessages
                                                                                                                                                          
                                                                                                                                                          	// The end time (exclusive) of raw message data that is reprocessed. If you specify
                                                                                                                                                          	// a value for the endTime parameter, you must not use the channelMessages object.
                                                                                                                                                          	EndTime *time.Time
                                                                                                                                                          
                                                                                                                                                          	// The start time (inclusive) of raw message data that is reprocessed. If you
                                                                                                                                                          	// specify a value for the startTime parameter, you must not use the
                                                                                                                                                          	// channelMessages object.
                                                                                                                                                          	StartTime *time.Time
                                                                                                                                                          }

                                                                                                                                                          type StartPipelineReprocessingOutput

                                                                                                                                                          type StartPipelineReprocessingOutput struct {
                                                                                                                                                          
                                                                                                                                                          	// The ID of the pipeline reprocessing activity that was started.
                                                                                                                                                          	ReprocessingId *string
                                                                                                                                                          
                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                          }

                                                                                                                                                          type TagResourceInput

                                                                                                                                                          type TagResourceInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The ARN of the resource whose tags you want to modify.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	ResourceArn *string
                                                                                                                                                          
                                                                                                                                                          	// The new or modified tags for the resource.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	Tags []types.Tag
                                                                                                                                                          }

                                                                                                                                                          type TagResourceOutput

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

                                                                                                                                                          type UntagResourceInput

                                                                                                                                                          type UntagResourceInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The ARN of the resource whose tags you want to remove.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	ResourceArn *string
                                                                                                                                                          
                                                                                                                                                          	// The keys of those tags which you want to remove.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	TagKeys []string
                                                                                                                                                          }

                                                                                                                                                          type UntagResourceOutput

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

                                                                                                                                                          type UpdateChannelInput

                                                                                                                                                          type UpdateChannelInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The name of the channel to be updated.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	ChannelName *string
                                                                                                                                                          
                                                                                                                                                          	// 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.
                                                                                                                                                          	ChannelStorage *types.ChannelStorage
                                                                                                                                                          
                                                                                                                                                          	// How long, in days, message data is kept for the channel. The retention period
                                                                                                                                                          	// cannot be updated if the channel's S3 storage is customer-managed.
                                                                                                                                                          	RetentionPeriod *types.RetentionPeriod
                                                                                                                                                          }

                                                                                                                                                          type UpdateChannelOutput

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

                                                                                                                                                          type UpdateDatasetInput

                                                                                                                                                          type UpdateDatasetInput struct {
                                                                                                                                                          
                                                                                                                                                          	// A list of DatasetAction objects.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	Actions []types.DatasetAction
                                                                                                                                                          
                                                                                                                                                          	// The name of the data set to update.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	DatasetName *string
                                                                                                                                                          
                                                                                                                                                          	// When dataset contents are created, they are delivered to destinations specified
                                                                                                                                                          	// here.
                                                                                                                                                          	ContentDeliveryRules []types.DatasetContentDeliveryRule
                                                                                                                                                          
                                                                                                                                                          	// 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 []types.LateDataRule
                                                                                                                                                          
                                                                                                                                                          	// How long, in days, dataset contents are kept for the dataset.
                                                                                                                                                          	RetentionPeriod *types.RetentionPeriod
                                                                                                                                                          
                                                                                                                                                          	// A list of DatasetTrigger objects. The list can be empty or can contain up to
                                                                                                                                                          	// five DatasetTrigger objects.
                                                                                                                                                          	Triggers []types.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 *types.VersioningConfiguration
                                                                                                                                                          }

                                                                                                                                                          type UpdateDatasetOutput

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

                                                                                                                                                          type UpdateDatastoreInput

                                                                                                                                                          type UpdateDatastoreInput struct {
                                                                                                                                                          
                                                                                                                                                          	// The name of the data store to be updated.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	DatastoreName *string
                                                                                                                                                          
                                                                                                                                                          	// Where data store data is stored. You can choose one of serviceManagedS3 or
                                                                                                                                                          	// customerManagedS3 storage. If not specified, the default isserviceManagedS3. You
                                                                                                                                                          	// cannot change this storage option after the data store is created.
                                                                                                                                                          	DatastoreStorage types.DatastoreStorage
                                                                                                                                                          
                                                                                                                                                          	// 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 *types.FileFormatConfiguration
                                                                                                                                                          
                                                                                                                                                          	// How long, in days, message data is kept for the data store. The retention period
                                                                                                                                                          	// cannot be updated if the data store's S3 storage is customer-managed.
                                                                                                                                                          	RetentionPeriod *types.RetentionPeriod
                                                                                                                                                          }

                                                                                                                                                          type UpdateDatastoreOutput

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

                                                                                                                                                          type UpdatePipelineInput

                                                                                                                                                          type UpdatePipelineInput struct {
                                                                                                                                                          
                                                                                                                                                          	// A list of PipelineActivity objects. Activities perform transformations on your
                                                                                                                                                          	// messages, such as removing, renaming or adding message attributes; filtering
                                                                                                                                                          	// messages based on attribute values; invoking your Lambda functions on messages
                                                                                                                                                          	// for advanced processing; or performing mathematical transformations to normalize
                                                                                                                                                          	// device data. The list can be 2-25 PipelineActivity objects and must contain both
                                                                                                                                                          	// a channel and a datastore activity. Each entry in the list must contain only one
                                                                                                                                                          	// activity. For example: pipelineActivities = [ { "channel": { ... } }, {
                                                                                                                                                          	// "lambda": { ... } }, ... ]
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	PipelineActivities []types.PipelineActivity
                                                                                                                                                          
                                                                                                                                                          	// The name of the pipeline to update.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	PipelineName *string
                                                                                                                                                          }

                                                                                                                                                          type UpdatePipelineOutput

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

                                                                                                                                                          Directories

                                                                                                                                                          Path Synopsis
                                                                                                                                                          internal