Documentation

Overview

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

    AWS IoT Events monitors your equipment or device fleets for failures or changes in operation, and triggers actions when such events occur. You can use AWS IoT Events API operations to create, read, update, and delete inputs and detector models, and to list their versions.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2018-07-27"
    View Source
    const ServiceID = "IoT Events"

    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 Client

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

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

            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) CreateDetectorModel

                func (c *Client) CreateDetectorModel(ctx context.Context, params *CreateDetectorModelInput, optFns ...func(*Options)) (*CreateDetectorModelOutput, error)

                  Creates a detector model.

                  func (*Client) CreateInput

                  func (c *Client) CreateInput(ctx context.Context, params *CreateInputInput, optFns ...func(*Options)) (*CreateInputOutput, error)

                    Creates an input.

                    func (*Client) DeleteDetectorModel

                    func (c *Client) DeleteDetectorModel(ctx context.Context, params *DeleteDetectorModelInput, optFns ...func(*Options)) (*DeleteDetectorModelOutput, error)

                      Deletes a detector model. Any active instances of the detector model are also deleted.

                      func (*Client) DeleteInput

                      func (c *Client) DeleteInput(ctx context.Context, params *DeleteInputInput, optFns ...func(*Options)) (*DeleteInputOutput, error)

                        Deletes an input.

                        func (*Client) DescribeDetectorModel

                        func (c *Client) DescribeDetectorModel(ctx context.Context, params *DescribeDetectorModelInput, optFns ...func(*Options)) (*DescribeDetectorModelOutput, error)

                          Describes a detector model. If the version parameter is not specified, information about the latest version is returned.

                          func (*Client) DescribeInput

                          func (c *Client) DescribeInput(ctx context.Context, params *DescribeInputInput, optFns ...func(*Options)) (*DescribeInputOutput, error)

                            Describes an input.

                            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 Events logging options.

                              func (*Client) ListDetectorModelVersions

                              func (c *Client) ListDetectorModelVersions(ctx context.Context, params *ListDetectorModelVersionsInput, optFns ...func(*Options)) (*ListDetectorModelVersionsOutput, error)

                                Lists all the versions of a detector model. Only the metadata associated with each detector model version is returned.

                                func (*Client) ListDetectorModels

                                func (c *Client) ListDetectorModels(ctx context.Context, params *ListDetectorModelsInput, optFns ...func(*Options)) (*ListDetectorModelsOutput, error)

                                  Lists the detector models you have created. Only the metadata associated with each detector model is returned.

                                  func (*Client) ListInputs

                                  func (c *Client) ListInputs(ctx context.Context, params *ListInputsInput, optFns ...func(*Options)) (*ListInputsOutput, error)

                                    Lists the inputs you have created.

                                    func (*Client) ListTagsForResource

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

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

                                      func (*Client) PutLoggingOptions

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

                                        Sets or updates the AWS IoT Events logging options. If you update the value of any loggingOptions field, it takes up to one minute for the change to take effect. 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) 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) UpdateDetectorModel

                                            func (c *Client) UpdateDetectorModel(ctx context.Context, params *UpdateDetectorModelInput, optFns ...func(*Options)) (*UpdateDetectorModelOutput, error)

                                              Updates a detector model. Detectors (instances) spawned by the previous version are deleted and then re-created as new inputs arrive.

                                              func (*Client) UpdateInput

                                              func (c *Client) UpdateInput(ctx context.Context, params *UpdateInputInput, optFns ...func(*Options)) (*UpdateInputOutput, error)

                                                Updates an input.

                                                type CreateDetectorModelInput

                                                type CreateDetectorModelInput struct {
                                                
                                                	// Information that defines how the detectors operate.
                                                	//
                                                	// This member is required.
                                                	DetectorModelDefinition *types.DetectorModelDefinition
                                                
                                                	// The name of the detector model.
                                                	//
                                                	// This member is required.
                                                	DetectorModelName *string
                                                
                                                	// The ARN of the role that grants permission to AWS IoT Events to perform its
                                                	// operations.
                                                	//
                                                	// This member is required.
                                                	RoleArn *string
                                                
                                                	// A brief description of the detector model.
                                                	DetectorModelDescription *string
                                                
                                                	// Information about the order in which events are evaluated and how actions are
                                                	// executed.
                                                	EvaluationMethod types.EvaluationMethod
                                                
                                                	// The input attribute key used to identify a device or system to create a detector
                                                	// (an instance of the detector model) and then to route each input received to the
                                                	// appropriate detector (instance). This parameter uses a JSON-path expression in
                                                	// the message payload of each input to specify the attribute-value pair that is
                                                	// used to identify the device associated with the input.
                                                	Key *string
                                                
                                                	// Metadata that can be used to manage the detector model.
                                                	Tags []types.Tag
                                                }

                                                type CreateDetectorModelOutput

                                                type CreateDetectorModelOutput struct {
                                                
                                                	// Information about how the detector model is configured.
                                                	DetectorModelConfiguration *types.DetectorModelConfiguration
                                                
                                                	// Metadata pertaining to the operation's result.
                                                	ResultMetadata middleware.Metadata
                                                }

                                                type CreateInputInput

                                                type CreateInputInput struct {
                                                
                                                	// The definition of the input.
                                                	//
                                                	// This member is required.
                                                	InputDefinition *types.InputDefinition
                                                
                                                	// The name you want to give to the input.
                                                	//
                                                	// This member is required.
                                                	InputName *string
                                                
                                                	// A brief description of the input.
                                                	InputDescription *string
                                                
                                                	// Metadata that can be used to manage the input.
                                                	Tags []types.Tag
                                                }

                                                type CreateInputOutput

                                                type CreateInputOutput struct {
                                                
                                                	// Information about the configuration of the input.
                                                	InputConfiguration *types.InputConfiguration
                                                
                                                	// Metadata pertaining to the operation's result.
                                                	ResultMetadata middleware.Metadata
                                                }

                                                type DeleteDetectorModelInput

                                                type DeleteDetectorModelInput struct {
                                                
                                                	// The name of the detector model to be deleted.
                                                	//
                                                	// This member is required.
                                                	DetectorModelName *string
                                                }

                                                type DeleteDetectorModelOutput

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

                                                type DeleteInputInput

                                                type DeleteInputInput struct {
                                                
                                                	// The name of the input to delete.
                                                	//
                                                	// This member is required.
                                                	InputName *string
                                                }

                                                type DeleteInputOutput

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

                                                type DescribeDetectorModelInput

                                                type DescribeDetectorModelInput struct {
                                                
                                                	// The name of the detector model.
                                                	//
                                                	// This member is required.
                                                	DetectorModelName *string
                                                
                                                	// The version of the detector model.
                                                	DetectorModelVersion *string
                                                }

                                                type DescribeDetectorModelOutput

                                                type DescribeDetectorModelOutput struct {
                                                
                                                	// Information about the detector model.
                                                	DetectorModel *types.DetectorModel
                                                
                                                	// Metadata pertaining to the operation's result.
                                                	ResultMetadata middleware.Metadata
                                                }

                                                type DescribeInputInput

                                                type DescribeInputInput struct {
                                                
                                                	// The name of the input.
                                                	//
                                                	// This member is required.
                                                	InputName *string
                                                }

                                                type DescribeInputOutput

                                                type DescribeInputOutput struct {
                                                
                                                	// Information about the input.
                                                	Input *types.Input
                                                
                                                	// 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 Events logging options.
                                                	LoggingOptions *types.LoggingOptions
                                                
                                                	// 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 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 ListDetectorModelVersionsInput

                                                        type ListDetectorModelVersionsInput struct {
                                                        
                                                        	// The name of the detector model whose versions are returned.
                                                        	//
                                                        	// This member is required.
                                                        	DetectorModelName *string
                                                        
                                                        	// The maximum number of results to return at one time.
                                                        	MaxResults *int32
                                                        
                                                        	// The token for the next set of results.
                                                        	NextToken *string
                                                        }

                                                        type ListDetectorModelVersionsOutput

                                                        type ListDetectorModelVersionsOutput struct {
                                                        
                                                        	// Summary information about the detector model versions.
                                                        	DetectorModelVersionSummaries []types.DetectorModelVersionSummary
                                                        
                                                        	// A token to retrieve the next set of results, or null if there are no additional
                                                        	// results.
                                                        	NextToken *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type ListDetectorModelsInput

                                                        type ListDetectorModelsInput struct {
                                                        
                                                        	// The maximum number of results to return at one time.
                                                        	MaxResults *int32
                                                        
                                                        	// The token for the next set of results.
                                                        	NextToken *string
                                                        }

                                                        type ListDetectorModelsOutput

                                                        type ListDetectorModelsOutput struct {
                                                        
                                                        	// Summary information about the detector models.
                                                        	DetectorModelSummaries []types.DetectorModelSummary
                                                        
                                                        	// A token to retrieve the next set of results, or null if there are no additional
                                                        	// results.
                                                        	NextToken *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type ListInputsInput

                                                        type ListInputsInput struct {
                                                        
                                                        	// The maximum number of results to return at one time.
                                                        	MaxResults *int32
                                                        
                                                        	// The token for the next set of results.
                                                        	NextToken *string
                                                        }

                                                        type ListInputsOutput

                                                        type ListInputsOutput struct {
                                                        
                                                        	// Summary information about the inputs.
                                                        	InputSummaries []types.InputSummary
                                                        
                                                        	// A token to retrieve the next set of results, or null if there are no additional
                                                        	// results.
                                                        	NextToken *string
                                                        
                                                        	// Metadata pertaining to the operation's result.
                                                        	ResultMetadata middleware.Metadata
                                                        }

                                                        type ListTagsForResourceInput

                                                        type ListTagsForResourceInput struct {
                                                        
                                                        	// The ARN of the resource.
                                                        	//
                                                        	// This member is required.
                                                        	ResourceArn *string
                                                        }

                                                        type ListTagsForResourceOutput

                                                        type ListTagsForResourceOutput struct {
                                                        
                                                        	// The list of tags 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 Events 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 TagResourceInput

                                                          type TagResourceInput struct {
                                                          
                                                          	// The ARN of the resource.
                                                          	//
                                                          	// 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.
                                                          	//
                                                          	// This member is required.
                                                          	ResourceArn *string
                                                          
                                                          	// A list of the keys of the tags to be removed from the resource.
                                                          	//
                                                          	// This member is required.
                                                          	TagKeys []string
                                                          }

                                                          type UntagResourceOutput

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

                                                          type UpdateDetectorModelInput

                                                          type UpdateDetectorModelInput struct {
                                                          
                                                          	// Information that defines how a detector operates.
                                                          	//
                                                          	// This member is required.
                                                          	DetectorModelDefinition *types.DetectorModelDefinition
                                                          
                                                          	// The name of the detector model that is updated.
                                                          	//
                                                          	// This member is required.
                                                          	DetectorModelName *string
                                                          
                                                          	// The ARN of the role that grants permission to AWS IoT Events to perform its
                                                          	// operations.
                                                          	//
                                                          	// This member is required.
                                                          	RoleArn *string
                                                          
                                                          	// A brief description of the detector model.
                                                          	DetectorModelDescription *string
                                                          
                                                          	// Information about the order in which events are evaluated and how actions are
                                                          	// executed.
                                                          	EvaluationMethod types.EvaluationMethod
                                                          }

                                                          type UpdateDetectorModelOutput

                                                          type UpdateDetectorModelOutput struct {
                                                          
                                                          	// Information about how the detector model is configured.
                                                          	DetectorModelConfiguration *types.DetectorModelConfiguration
                                                          
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          type UpdateInputInput

                                                          type UpdateInputInput struct {
                                                          
                                                          	// The definition of the input.
                                                          	//
                                                          	// This member is required.
                                                          	InputDefinition *types.InputDefinition
                                                          
                                                          	// The name of the input you want to update.
                                                          	//
                                                          	// This member is required.
                                                          	InputName *string
                                                          
                                                          	// A brief description of the input.
                                                          	InputDescription *string
                                                          }

                                                          type UpdateInputOutput

                                                          type UpdateInputOutput struct {
                                                          
                                                          	// Information about the configuration of the input.
                                                          	InputConfiguration *types.InputConfiguration
                                                          
                                                          	// Metadata pertaining to the operation's result.
                                                          	ResultMetadata middleware.Metadata
                                                          }

                                                          Directories

                                                          Path Synopsis
                                                          internal