Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Archive

type Archive struct {

	// The name of the archive.
	ArchiveName *string

	// The time stamp for the time that the archive was created.
	CreationTime *time.Time

	// The number of events in the archive.
	EventCount int64

	// The ARN of the event bus associated with the archive. Only events from this
	// event bus are sent to the archive.
	EventSourceArn *string

	// The number of days to retain events in the archive before they are deleted.
	RetentionDays *int32

	// The size of the archive, in bytes.
	SizeBytes int64

	// The current state of the archive.
	State ArchiveState

	// A description for the reason that the archive is in the current state.
	StateReason *string
}

    An Archive object that contains details about an archive.

    type ArchiveState

    type ArchiveState string
    const (
    	ArchiveStateEnabled      ArchiveState = "ENABLED"
    	ArchiveStateDisabled     ArchiveState = "DISABLED"
    	ArchiveStateCreating     ArchiveState = "CREATING"
    	ArchiveStateUpdating     ArchiveState = "UPDATING"
    	ArchiveStateCreateFailed ArchiveState = "CREATE_FAILED"
    	ArchiveStateUpdateFailed ArchiveState = "UPDATE_FAILED"
    )

      Enum values for ArchiveState

      func (ArchiveState) Values

      func (ArchiveState) Values() []ArchiveState

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

        type AssignPublicIp

        type AssignPublicIp string
        const (
        	AssignPublicIpEnabled  AssignPublicIp = "ENABLED"
        	AssignPublicIpDisabled AssignPublicIp = "DISABLED"
        )

          Enum values for AssignPublicIp

          func (AssignPublicIp) Values

          func (AssignPublicIp) Values() []AssignPublicIp

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

            type AwsVpcConfiguration

            type AwsVpcConfiguration struct {
            
            	// Specifies the subnets associated with the task. These subnets must all be in the
            	// same VPC. You can specify as many as 16 subnets.
            	//
            	// This member is required.
            	Subnets []string
            
            	// Specifies whether the task's elastic network interface receives a public IP
            	// address. You can specify ENABLED only when LaunchType in EcsParameters is set to
            	// FARGATE.
            	AssignPublicIp AssignPublicIp
            
            	// Specifies the security groups associated with the task. These security groups
            	// must all be in the same VPC. You can specify as many as five security groups. If
            	// you do not specify a security group, the default security group for the VPC is
            	// used.
            	SecurityGroups []string
            }

              This structure specifies the VPC subnets and security groups for the task, and whether a public IP address is to be used. This structure is relevant only for ECS tasks that use the awsvpc network mode.

              type BatchArrayProperties

              type BatchArrayProperties struct {
              
              	// The size of the array, if this is an array batch job. Valid values are integers
              	// between 2 and 10,000.
              	Size int32
              }

                The array properties for the submitted job, such as the size of the array. The array size can be between 2 and 10,000. If you specify array properties for a job, it becomes an array job. This parameter is used only if the target is an AWS Batch job.

                type BatchParameters

                type BatchParameters struct {
                
                	// The ARN or name of the job definition to use if the event target is an AWS Batch
                	// job. This job definition must already exist.
                	//
                	// This member is required.
                	JobDefinition *string
                
                	// The name to use for this execution of the job, if the target is an AWS Batch
                	// job.
                	//
                	// This member is required.
                	JobName *string
                
                	// The array properties for the submitted job, such as the size of the array. The
                	// array size can be between 2 and 10,000. If you specify array properties for a
                	// job, it becomes an array job. This parameter is used only if the target is an
                	// AWS Batch job.
                	ArrayProperties *BatchArrayProperties
                
                	// The retry strategy to use for failed jobs, if the target is an AWS Batch job.
                	// The retry strategy is the number of times to retry the failed job execution.
                	// Valid values are 1–10. When you specify a retry strategy here, it overrides the
                	// retry strategy defined in the job definition.
                	RetryStrategy *BatchRetryStrategy
                }

                  The custom parameters to be used when the target is an AWS Batch job.

                  type BatchRetryStrategy

                  type BatchRetryStrategy struct {
                  
                  	// The number of times to attempt to retry, if the job fails. Valid values are
                  	// 1–10.
                  	Attempts int32
                  }

                    The retry strategy to use for failed jobs, if the target is an AWS Batch job. If you specify a retry strategy here, it overrides the retry strategy defined in the job definition.

                    type ConcurrentModificationException

                    type ConcurrentModificationException struct {
                    	Message *string
                    }

                      There is concurrent modification on a rule, target, archive, or replay.

                      func (*ConcurrentModificationException) Error

                      func (*ConcurrentModificationException) ErrorCode

                      func (e *ConcurrentModificationException) ErrorCode() string

                      func (*ConcurrentModificationException) ErrorFault

                      func (*ConcurrentModificationException) ErrorMessage

                      func (e *ConcurrentModificationException) ErrorMessage() string

                      type Condition

                      type Condition struct {
                      
                      	// Specifies the key for the condition. Currently the only supported key is
                      	// aws:PrincipalOrgID.
                      	//
                      	// This member is required.
                      	Key *string
                      
                      	// Specifies the type of condition. Currently the only supported value is
                      	// StringEquals.
                      	//
                      	// This member is required.
                      	Type *string
                      
                      	// Specifies the value for the key. Currently, this must be the ID of the
                      	// organization.
                      	//
                      	// This member is required.
                      	Value *string
                      }

                        A JSON string which you can use to limit the event bus permissions you are granting to only accounts that fulfill the condition. Currently, the only supported condition is membership in a certain AWS organization. The string must contain Type, Key, and Value fields. The Value field specifies the ID of the AWS organization. Following is an example value for Condition: '{"Type" : "StringEquals", "Key": "aws:PrincipalOrgID", "Value": "o-1234567890"}'

                        type DeadLetterConfig

                        type DeadLetterConfig struct {
                        
                        	// The ARN of the SQS queue specified as the target for the dead-letter queue.
                        	Arn *string
                        }

                          A DeadLetterConfig object that contains information about a dead-letter queue configuration.

                          type EcsParameters

                          type EcsParameters struct {
                          
                          	// The ARN of the task definition to use if the event target is an Amazon ECS task.
                          	//
                          	// This member is required.
                          	TaskDefinitionArn *string
                          
                          	// Specifies an ECS task group for the task. The maximum length is 255 characters.
                          	Group *string
                          
                          	// Specifies the launch type on which your task is running. The launch type that
                          	// you specify here must match one of the launch type (compatibilities) of the
                          	// target task. The FARGATE value is supported only in the Regions where AWS
                          	// Fargate with Amazon ECS is supported. For more information, see AWS Fargate on
                          	// Amazon ECS
                          	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS-Fargate.html)
                          	// in the Amazon Elastic Container Service Developer Guide.
                          	LaunchType LaunchType
                          
                          	// Use this structure if the ECS task uses the awsvpc network mode. This structure
                          	// specifies the VPC subnets and security groups associated with the task, and
                          	// whether a public IP address is to be used. This structure is required if
                          	// LaunchType is FARGATE because the awsvpc mode is required for Fargate tasks. If
                          	// you specify NetworkConfiguration when the target ECS task does not use the
                          	// awsvpc network mode, the task fails.
                          	NetworkConfiguration *NetworkConfiguration
                          
                          	// Specifies the platform version for the task. Specify only the numeric portion of
                          	// the platform version, such as 1.1.0. This structure is used only if LaunchType
                          	// is FARGATE. For more information about valid platform versions, see AWS Fargate
                          	// Platform Versions
                          	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
                          	// in the Amazon Elastic Container Service Developer Guide.
                          	PlatformVersion *string
                          
                          	// The number of tasks to create based on TaskDefinition. The default is 1.
                          	TaskCount *int32
                          }

                            The custom parameters to be used when the target is an Amazon ECS task.

                            type EventBus

                            type EventBus struct {
                            
                            	// The ARN of the event bus.
                            	Arn *string
                            
                            	// The name of the event bus.
                            	Name *string
                            
                            	// The permissions policy of the event bus, describing which other AWS accounts can
                            	// write events to this event bus.
                            	Policy *string
                            }

                              An event bus receives events from a source and routes them to rules associated with that event bus. Your account's default event bus receives rules from AWS services. A custom event bus can receive rules from AWS services as well as your custom applications and services. A partner event bus receives events from an event source created by an SaaS partner. These events come from the partners services or applications.

                              type EventSource

                              type EventSource struct {
                              
                              	// The ARN of the event source.
                              	Arn *string
                              
                              	// The name of the partner that created the event source.
                              	CreatedBy *string
                              
                              	// The date and time the event source was created.
                              	CreationTime *time.Time
                              
                              	// The date and time that the event source will expire, if the AWS account doesn't
                              	// create a matching event bus for it.
                              	ExpirationTime *time.Time
                              
                              	// The name of the event source.
                              	Name *string
                              
                              	// The state of the event source. If it is ACTIVE, you have already created a
                              	// matching event bus for this event source, and that event bus is active. If it is
                              	// PENDING, either you haven't yet created a matching event bus, or that event bus
                              	// is deactivated. If it is DELETED, you have created a matching event bus, but the
                              	// event source has since been deleted.
                              	State EventSourceState
                              }

                                A partner event source is created by an SaaS partner. If a customer creates a partner event bus that matches this event source, that AWS account can receive events from the partner's applications or services.

                                type EventSourceState

                                type EventSourceState string
                                const (
                                	EventSourceStatePending EventSourceState = "PENDING"
                                	EventSourceStateActive  EventSourceState = "ACTIVE"
                                	EventSourceStateDeleted EventSourceState = "DELETED"
                                )

                                  Enum values for EventSourceState

                                  func (EventSourceState) Values

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

                                    type HttpParameters

                                    type HttpParameters struct {
                                    
                                    	// The headers that need to be sent as part of request invoking the API Gateway
                                    	// REST API.
                                    	HeaderParameters map[string]string
                                    
                                    	// The path parameter values to be used to populate API Gateway REST API path
                                    	// wildcards ("*").
                                    	PathParameterValues []string
                                    
                                    	// The query string keys/values that need to be sent as part of request invoking
                                    	// the API Gateway REST API.
                                    	QueryStringParameters map[string]string
                                    }

                                      These are custom parameter to be used when the target is an API Gateway REST APIs.

                                      type IllegalStatusException

                                      type IllegalStatusException struct {
                                      	Message *string
                                      }

                                        An error occurred because a replay can be canceled only when the state is Running or Starting.

                                        func (*IllegalStatusException) Error

                                        func (e *IllegalStatusException) Error() string

                                        func (*IllegalStatusException) ErrorCode

                                        func (e *IllegalStatusException) ErrorCode() string

                                        func (*IllegalStatusException) ErrorFault

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

                                        func (*IllegalStatusException) ErrorMessage

                                        func (e *IllegalStatusException) ErrorMessage() string

                                        type InputTransformer

                                        type InputTransformer struct {
                                        
                                        	// Input template where you specify placeholders that will be filled with the
                                        	// values of the keys from InputPathsMap to customize the data sent to the target.
                                        	// Enclose each InputPathsMaps value in brackets: <value> The InputTemplate must be
                                        	// valid JSON. If InputTemplate is a JSON object (surrounded by curly braces), the
                                        	// following restrictions apply:
                                        	//
                                        	// * The placeholder cannot be used as an object
                                        	// key.
                                        	//
                                        	// * Object values cannot include quote marks.
                                        	//
                                        	// The following example shows
                                        	// the syntax for using InputPathsMap and InputTemplate.  "InputTransformer":
                                        	//
                                        	// {
                                        	//
                                        	//     "InputPathsMap": {"instance": "$.detail.instance","status":
                                        	// "$.detail.status"},
                                        	//
                                        	//     "InputTemplate": " is in state "
                                        	//
                                        	// } To have the
                                        	// InputTemplate include quote marks within a JSON string, escape each quote marks
                                        	// with a slash, as in the following example:  "InputTransformer":
                                        	//     {
                                        	//
                                        	//
                                        	// "InputPathsMap": {"instance": "$.detail.instance","status":
                                        	// "$.detail.status"},
                                        	//
                                        	//     "InputTemplate": " is in state """
                                        	//
                                        	//     }
                                        	//
                                        	// This member is required.
                                        	InputTemplate *string
                                        
                                        	// Map of JSON paths to be extracted from the event. You can then insert these in
                                        	// the template in InputTemplate to produce the output you want to be sent to the
                                        	// target. InputPathsMap is an array key-value pairs, where each value is a valid
                                        	// JSON path. You can have as many as 10 key-value pairs. You must use JSON dot
                                        	// notation, not bracket notation. The keys cannot start with "AWS."
                                        	InputPathsMap map[string]string
                                        }

                                          Contains the parameters needed for you to provide custom input to a target based on one or more pieces of data extracted from the event.

                                          type InternalException

                                          type InternalException struct {
                                          	Message *string
                                          }

                                            This exception occurs due to unexpected causes.

                                            func (*InternalException) Error

                                            func (e *InternalException) Error() string

                                            func (*InternalException) ErrorCode

                                            func (e *InternalException) ErrorCode() string

                                            func (*InternalException) ErrorFault

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

                                            func (*InternalException) ErrorMessage

                                            func (e *InternalException) ErrorMessage() string

                                            type InvalidEventPatternException

                                            type InvalidEventPatternException struct {
                                            	Message *string
                                            }

                                              The event pattern is not valid.

                                              func (*InvalidEventPatternException) Error

                                              func (*InvalidEventPatternException) ErrorCode

                                              func (e *InvalidEventPatternException) ErrorCode() string

                                              func (*InvalidEventPatternException) ErrorFault

                                              func (*InvalidEventPatternException) ErrorMessage

                                              func (e *InvalidEventPatternException) ErrorMessage() string

                                              type InvalidStateException

                                              type InvalidStateException struct {
                                              	Message *string
                                              }

                                                The specified state is not a valid state for an event source.

                                                func (*InvalidStateException) Error

                                                func (e *InvalidStateException) Error() string

                                                func (*InvalidStateException) ErrorCode

                                                func (e *InvalidStateException) ErrorCode() string

                                                func (*InvalidStateException) ErrorFault

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

                                                func (*InvalidStateException) ErrorMessage

                                                func (e *InvalidStateException) ErrorMessage() string

                                                type KinesisParameters

                                                type KinesisParameters struct {
                                                
                                                	// The JSON path to be extracted from the event and used as the partition key. For
                                                	// more information, see Amazon Kinesis Streams Key Concepts
                                                	// (https://docs.aws.amazon.com/streams/latest/dev/key-concepts.html#partition-key)
                                                	// in the Amazon Kinesis Streams Developer Guide.
                                                	//
                                                	// This member is required.
                                                	PartitionKeyPath *string
                                                }

                                                  This object enables you to specify a JSON path to extract from the event and use as the partition key for the Amazon Kinesis data stream, so that you can control the shard to which the event goes. If you do not include this parameter, the default is to use the eventId as the partition key.

                                                  type LaunchType

                                                  type LaunchType string
                                                  const (
                                                  	LaunchTypeEc2     LaunchType = "EC2"
                                                  	LaunchTypeFargate LaunchType = "FARGATE"
                                                  )

                                                    Enum values for LaunchType

                                                    func (LaunchType) Values

                                                    func (LaunchType) Values() []LaunchType

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

                                                      type LimitExceededException

                                                      type LimitExceededException struct {
                                                      	Message *string
                                                      }

                                                        The request failed because it attempted to create resource beyond the allowed service quota.

                                                        func (*LimitExceededException) Error

                                                        func (e *LimitExceededException) Error() string

                                                        func (*LimitExceededException) ErrorCode

                                                        func (e *LimitExceededException) ErrorCode() string

                                                        func (*LimitExceededException) ErrorFault

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

                                                        func (*LimitExceededException) ErrorMessage

                                                        func (e *LimitExceededException) ErrorMessage() string

                                                        type ManagedRuleException

                                                        type ManagedRuleException struct {
                                                        	Message *string
                                                        }

                                                          This rule was created by an AWS service on behalf of your account. It is managed by that service. If you see this error in response to DeleteRule or RemoveTargets, you can use the Force parameter in those calls to delete the rule or remove targets from the rule. You cannot modify these managed rules by using DisableRule, EnableRule, PutTargets, PutRule, TagResource, or UntagResource.

                                                          func (*ManagedRuleException) Error

                                                          func (e *ManagedRuleException) Error() string

                                                          func (*ManagedRuleException) ErrorCode

                                                          func (e *ManagedRuleException) ErrorCode() string

                                                          func (*ManagedRuleException) ErrorFault

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

                                                          func (*ManagedRuleException) ErrorMessage

                                                          func (e *ManagedRuleException) ErrorMessage() string

                                                          type NetworkConfiguration

                                                          type NetworkConfiguration struct {
                                                          
                                                          	// Use this structure to specify the VPC subnets and security groups for the task,
                                                          	// and whether a public IP address is to be used. This structure is relevant only
                                                          	// for ECS tasks that use the awsvpc network mode.
                                                          	AwsvpcConfiguration *AwsVpcConfiguration
                                                          }

                                                            This structure specifies the network configuration for an ECS task.

                                                            type OperationDisabledException

                                                            type OperationDisabledException struct {
                                                            	Message *string
                                                            }

                                                              The operation you are attempting is not available in this region.

                                                              func (*OperationDisabledException) Error

                                                              func (*OperationDisabledException) ErrorCode

                                                              func (e *OperationDisabledException) ErrorCode() string

                                                              func (*OperationDisabledException) ErrorFault

                                                              func (*OperationDisabledException) ErrorMessage

                                                              func (e *OperationDisabledException) ErrorMessage() string

                                                              type PartnerEventSource

                                                              type PartnerEventSource struct {
                                                              
                                                              	// The ARN of the partner event source.
                                                              	Arn *string
                                                              
                                                              	// The name of the partner event source.
                                                              	Name *string
                                                              }

                                                                A partner event source is created by an SaaS partner. If a customer creates a partner event bus that matches this event source, that AWS account can receive events from the partner's applications or services.

                                                                type PartnerEventSourceAccount

                                                                type PartnerEventSourceAccount struct {
                                                                
                                                                	// The AWS account ID that the partner event source was offered to.
                                                                	Account *string
                                                                
                                                                	// The date and time the event source was created.
                                                                	CreationTime *time.Time
                                                                
                                                                	// The date and time that the event source will expire, if the AWS account doesn't
                                                                	// create a matching event bus for it.
                                                                	ExpirationTime *time.Time
                                                                
                                                                	// The state of the event source. If it is ACTIVE, you have already created a
                                                                	// matching event bus for this event source, and that event bus is active. If it is
                                                                	// PENDING, either you haven't yet created a matching event bus, or that event bus
                                                                	// is deactivated. If it is DELETED, you have created a matching event bus, but the
                                                                	// event source has since been deleted.
                                                                	State EventSourceState
                                                                }

                                                                  The AWS account that a partner event source has been offered to.

                                                                  type PolicyLengthExceededException

                                                                  type PolicyLengthExceededException struct {
                                                                  	Message *string
                                                                  }

                                                                    The event bus policy is too long. For more information, see the limits.

                                                                    func (*PolicyLengthExceededException) Error

                                                                    func (*PolicyLengthExceededException) ErrorCode

                                                                    func (e *PolicyLengthExceededException) ErrorCode() string

                                                                    func (*PolicyLengthExceededException) ErrorFault

                                                                    func (*PolicyLengthExceededException) ErrorMessage

                                                                    func (e *PolicyLengthExceededException) ErrorMessage() string

                                                                    type PutEventsRequestEntry

                                                                    type PutEventsRequestEntry struct {
                                                                    
                                                                    	// A valid JSON string. There is no other schema imposed. The JSON string may
                                                                    	// contain fields and nested subobjects.
                                                                    	Detail *string
                                                                    
                                                                    	// Free-form string used to decide what fields to expect in the event detail.
                                                                    	DetailType *string
                                                                    
                                                                    	// The name or ARN of the event bus to receive the event. Only the rules that are
                                                                    	// associated with this event bus are used to match the event. If you omit this,
                                                                    	// the default event bus is used.
                                                                    	EventBusName *string
                                                                    
                                                                    	// AWS resources, identified by Amazon Resource Name (ARN), which the event
                                                                    	// primarily concerns. Any number, including zero, may be present.
                                                                    	Resources []string
                                                                    
                                                                    	// The source of the event.
                                                                    	Source *string
                                                                    
                                                                    	// The time stamp of the event, per RFC3339
                                                                    	// (https://www.rfc-editor.org/rfc/rfc3339.txt). If no time stamp is provided, the
                                                                    	// time stamp of the PutEvents call is used.
                                                                    	Time *time.Time
                                                                    }

                                                                      Represents an event to be submitted.

                                                                      type PutEventsResultEntry

                                                                      type PutEventsResultEntry struct {
                                                                      
                                                                      	// The error code that indicates why the event submission failed.
                                                                      	ErrorCode *string
                                                                      
                                                                      	// The error message that explains why the event submission failed.
                                                                      	ErrorMessage *string
                                                                      
                                                                      	// The ID of the event.
                                                                      	EventId *string
                                                                      }

                                                                        Represents an event that failed to be submitted.

                                                                        type PutPartnerEventsRequestEntry

                                                                        type PutPartnerEventsRequestEntry struct {
                                                                        
                                                                        	// A valid JSON string. There is no other schema imposed. The JSON string may
                                                                        	// contain fields and nested subobjects.
                                                                        	Detail *string
                                                                        
                                                                        	// A free-form string used to decide what fields to expect in the event detail.
                                                                        	DetailType *string
                                                                        
                                                                        	// AWS resources, identified by Amazon Resource Name (ARN), which the event
                                                                        	// primarily concerns. Any number, including zero, may be present.
                                                                        	Resources []string
                                                                        
                                                                        	// The event source that is generating the evntry.
                                                                        	Source *string
                                                                        
                                                                        	// The date and time of the event.
                                                                        	Time *time.Time
                                                                        }

                                                                          The details about an event generated by an SaaS partner.

                                                                          type PutPartnerEventsResultEntry

                                                                          type PutPartnerEventsResultEntry struct {
                                                                          
                                                                          	// The error code that indicates why the event submission failed.
                                                                          	ErrorCode *string
                                                                          
                                                                          	// The error message that explains why the event submission failed.
                                                                          	ErrorMessage *string
                                                                          
                                                                          	// The ID of the event.
                                                                          	EventId *string
                                                                          }

                                                                            Represents an event that a partner tried to generate, but failed.

                                                                            type PutTargetsResultEntry

                                                                            type PutTargetsResultEntry struct {
                                                                            
                                                                            	// The error code that indicates why the target addition failed. If the value is
                                                                            	// ConcurrentModificationException, too many requests were made at the same time.
                                                                            	ErrorCode *string
                                                                            
                                                                            	// The error message that explains why the target addition failed.
                                                                            	ErrorMessage *string
                                                                            
                                                                            	// The ID of the target.
                                                                            	TargetId *string
                                                                            }

                                                                              Represents a target that failed to be added to a rule.

                                                                              type RedshiftDataParameters

                                                                              type RedshiftDataParameters struct {
                                                                              
                                                                              	// The name of the database. Required when authenticating using temporary
                                                                              	// credentials.
                                                                              	//
                                                                              	// This member is required.
                                                                              	Database *string
                                                                              
                                                                              	// The SQL statement text to run.
                                                                              	//
                                                                              	// This member is required.
                                                                              	Sql *string
                                                                              
                                                                              	// The database user name. Required when authenticating using temporary
                                                                              	// credentials.
                                                                              	DbUser *string
                                                                              
                                                                              	// The name or ARN of the secret that enables access to the database. Required when
                                                                              	// authenticating using AWS Secrets Manager.
                                                                              	SecretManagerArn *string
                                                                              
                                                                              	// The name of the SQL statement. You can name the SQL statement when you create it
                                                                              	// to identify the query.
                                                                              	StatementName *string
                                                                              
                                                                              	// Indicates whether to send an event back to EventBridge after the SQL statement
                                                                              	// runs.
                                                                              	WithEvent bool
                                                                              }

                                                                                These are custom parameters to be used when the target is a Redshift cluster to invoke the Redshift Data API ExecuteStatement based on EventBridge events.

                                                                                type RemoveTargetsResultEntry

                                                                                type RemoveTargetsResultEntry struct {
                                                                                
                                                                                	// The error code that indicates why the target removal failed. If the value is
                                                                                	// ConcurrentModificationException, too many requests were made at the same time.
                                                                                	ErrorCode *string
                                                                                
                                                                                	// The error message that explains why the target removal failed.
                                                                                	ErrorMessage *string
                                                                                
                                                                                	// The ID of the target.
                                                                                	TargetId *string
                                                                                }

                                                                                  Represents a target that failed to be removed from a rule.

                                                                                  type Replay

                                                                                  type Replay struct {
                                                                                  
                                                                                  	// A time stamp for the time to start replaying events. Any event with a creation
                                                                                  	// time prior to the EventEndTime specified is replayed.
                                                                                  	EventEndTime *time.Time
                                                                                  
                                                                                  	// A time stamp for the time that the last event was replayed.
                                                                                  	EventLastReplayedTime *time.Time
                                                                                  
                                                                                  	// The ARN of the archive to replay event from.
                                                                                  	EventSourceArn *string
                                                                                  
                                                                                  	// A time stamp for the time to start replaying events. This is determined by the
                                                                                  	// time in the event as described in Time
                                                                                  	// (https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEventsRequestEntry.html#eventbridge-Type-PutEventsRequestEntry-Time).
                                                                                  	EventStartTime *time.Time
                                                                                  
                                                                                  	// A time stamp for the time that the replay completed.
                                                                                  	ReplayEndTime *time.Time
                                                                                  
                                                                                  	// The name of the replay.
                                                                                  	ReplayName *string
                                                                                  
                                                                                  	// A time stamp for the time that the replay started.
                                                                                  	ReplayStartTime *time.Time
                                                                                  
                                                                                  	// The current state of the replay.
                                                                                  	State ReplayState
                                                                                  
                                                                                  	// A description of why the replay is in the current state.
                                                                                  	StateReason *string
                                                                                  }

                                                                                    A Replay object that contains details about a replay.

                                                                                    type ReplayDestination

                                                                                    type ReplayDestination struct {
                                                                                    
                                                                                    	// The ARN of the event bus to replay event to. You can replay events only to the
                                                                                    	// event bus specified to create the archive.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Arn *string
                                                                                    
                                                                                    	// A list of ARNs for rules to replay events to.
                                                                                    	FilterArns []string
                                                                                    }

                                                                                      A ReplayDestination object that contains details about a replay.

                                                                                      type ReplayState

                                                                                      type ReplayState string
                                                                                      const (
                                                                                      	ReplayStateStarting   ReplayState = "STARTING"
                                                                                      	ReplayStateRunning    ReplayState = "RUNNING"
                                                                                      	ReplayStateCancelling ReplayState = "CANCELLING"
                                                                                      	ReplayStateCompleted  ReplayState = "COMPLETED"
                                                                                      	ReplayStateCancelled  ReplayState = "CANCELLED"
                                                                                      	ReplayStateFailed     ReplayState = "FAILED"
                                                                                      )

                                                                                        Enum values for ReplayState

                                                                                        func (ReplayState) Values

                                                                                        func (ReplayState) Values() []ReplayState

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

                                                                                          type ResourceAlreadyExistsException

                                                                                          type ResourceAlreadyExistsException struct {
                                                                                          	Message *string
                                                                                          }

                                                                                            The resource you are trying to create already exists.

                                                                                            func (*ResourceAlreadyExistsException) Error

                                                                                            func (*ResourceAlreadyExistsException) ErrorCode

                                                                                            func (e *ResourceAlreadyExistsException) ErrorCode() string

                                                                                            func (*ResourceAlreadyExistsException) ErrorFault

                                                                                            func (*ResourceAlreadyExistsException) ErrorMessage

                                                                                            func (e *ResourceAlreadyExistsException) ErrorMessage() string

                                                                                            type ResourceNotFoundException

                                                                                            type ResourceNotFoundException struct {
                                                                                            	Message *string
                                                                                            }

                                                                                              An entity that you specified does not exist.

                                                                                              func (*ResourceNotFoundException) Error

                                                                                              func (e *ResourceNotFoundException) Error() string

                                                                                              func (*ResourceNotFoundException) ErrorCode

                                                                                              func (e *ResourceNotFoundException) ErrorCode() string

                                                                                              func (*ResourceNotFoundException) ErrorFault

                                                                                              func (*ResourceNotFoundException) ErrorMessage

                                                                                              func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                              type RetryPolicy

                                                                                              type RetryPolicy struct {
                                                                                              
                                                                                              	// The maximum amount of time, in seconds, to continue to make retry attempts.
                                                                                              	MaximumEventAgeInSeconds *int32
                                                                                              
                                                                                              	// The maximum number of retry attempts to make before the request fails. Retry
                                                                                              	// attempts continue until either the maximum number of attempts is made or until
                                                                                              	// the duration of the MaximumEventAgeInSeconds is met.
                                                                                              	MaximumRetryAttempts *int32
                                                                                              }

                                                                                                A RetryPolicy object that includes information about the retry policy settings.

                                                                                                type Rule

                                                                                                type Rule struct {
                                                                                                
                                                                                                	// The Amazon Resource Name (ARN) of the rule.
                                                                                                	Arn *string
                                                                                                
                                                                                                	// The description of the rule.
                                                                                                	Description *string
                                                                                                
                                                                                                	// The name or ARN of the event bus associated with the rule. If you omit this, the
                                                                                                	// default event bus is used.
                                                                                                	EventBusName *string
                                                                                                
                                                                                                	// The event pattern of the rule. For more information, see Events and Event
                                                                                                	// Patterns
                                                                                                	// (https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html)
                                                                                                	// in the Amazon EventBridge User Guide.
                                                                                                	EventPattern *string
                                                                                                
                                                                                                	// If the rule was created on behalf of your account by an AWS service, this field
                                                                                                	// displays the principal name of the service that created the rule.
                                                                                                	ManagedBy *string
                                                                                                
                                                                                                	// The name of the rule.
                                                                                                	Name *string
                                                                                                
                                                                                                	// The Amazon Resource Name (ARN) of the role that is used for target invocation.
                                                                                                	RoleArn *string
                                                                                                
                                                                                                	// The scheduling expression. For example, "cron(0 20 * * ? *)", "rate(5 minutes)".
                                                                                                	ScheduleExpression *string
                                                                                                
                                                                                                	// The state of the rule.
                                                                                                	State RuleState
                                                                                                }

                                                                                                  Contains information about a rule in Amazon EventBridge.

                                                                                                  type RuleState

                                                                                                  type RuleState string
                                                                                                  const (
                                                                                                  	RuleStateEnabled  RuleState = "ENABLED"
                                                                                                  	RuleStateDisabled RuleState = "DISABLED"
                                                                                                  )

                                                                                                    Enum values for RuleState

                                                                                                    func (RuleState) Values

                                                                                                    func (RuleState) Values() []RuleState

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

                                                                                                      type RunCommandParameters

                                                                                                      type RunCommandParameters struct {
                                                                                                      
                                                                                                      	// Currently, we support including only one RunCommandTarget block, which specifies
                                                                                                      	// either an array of InstanceIds or a tag.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	RunCommandTargets []RunCommandTarget
                                                                                                      }

                                                                                                        This parameter contains the criteria (either InstanceIds or a tag) used to specify which EC2 instances are to be sent the command.

                                                                                                        type RunCommandTarget

                                                                                                        type RunCommandTarget struct {
                                                                                                        
                                                                                                        	// Can be either tag: tag-key or InstanceIds.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Key *string
                                                                                                        
                                                                                                        	// If Key is tag: tag-key, Values is a list of tag values. If Key is InstanceIds,
                                                                                                        	// Values is a list of Amazon EC2 instance IDs.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Values []string
                                                                                                        }

                                                                                                          Information about the EC2 instances that are to be sent the command, specified as key-value pairs. Each RunCommandTarget block can include only one key, but this key may specify multiple values.

                                                                                                          type SqsParameters

                                                                                                          type SqsParameters struct {
                                                                                                          
                                                                                                          	// The FIFO message group ID to use as the target.
                                                                                                          	MessageGroupId *string
                                                                                                          }

                                                                                                            This structure includes the custom parameter to be used when the target is an SQS FIFO queue.

                                                                                                            type Tag

                                                                                                            type Tag struct {
                                                                                                            
                                                                                                            	// A string you can use to assign a value. The combination of tag keys and values
                                                                                                            	// can help you organize and categorize your resources.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	Key *string
                                                                                                            
                                                                                                            	// The value for the specified tag key.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	Value *string
                                                                                                            }

                                                                                                              A key-value pair associated with an AWS resource. In EventBridge, rules and event buses support tagging.

                                                                                                              type Target

                                                                                                              type Target struct {
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the target.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Arn *string
                                                                                                              
                                                                                                              	// The ID of the target.
                                                                                                              	//
                                                                                                              	// This member is required.
                                                                                                              	Id *string
                                                                                                              
                                                                                                              	// If the event target is an AWS Batch job, this contains the job definition, job
                                                                                                              	// name, and other parameters. For more information, see Jobs
                                                                                                              	// (https://docs.aws.amazon.com/batch/latest/userguide/jobs.html) in the AWS Batch
                                                                                                              	// User Guide.
                                                                                                              	BatchParameters *BatchParameters
                                                                                                              
                                                                                                              	// The DeadLetterConfig that defines the target queue to send dead-letter queue
                                                                                                              	// events to.
                                                                                                              	DeadLetterConfig *DeadLetterConfig
                                                                                                              
                                                                                                              	// Contains the Amazon ECS task definition and task count to be used, if the event
                                                                                                              	// target is an Amazon ECS task. For more information about Amazon ECS tasks, see
                                                                                                              	// Task Definitions
                                                                                                              	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html)
                                                                                                              	// in the Amazon EC2 Container Service Developer Guide.
                                                                                                              	EcsParameters *EcsParameters
                                                                                                              
                                                                                                              	// Contains the HTTP parameters to use when the target is a API Gateway REST
                                                                                                              	// endpoint. If you specify an API Gateway REST API as a target, you can use this
                                                                                                              	// parameter to specify headers, path parameter, query string keys/values as part
                                                                                                              	// of your target invoking request.
                                                                                                              	HttpParameters *HttpParameters
                                                                                                              
                                                                                                              	// Valid JSON text passed to the target. In this case, nothing from the event
                                                                                                              	// itself is passed to the target. For more information, see The JavaScript Object
                                                                                                              	// Notation (JSON) Data Interchange Format
                                                                                                              	// (http://www.rfc-editor.org/rfc/rfc7159.txt).
                                                                                                              	Input *string
                                                                                                              
                                                                                                              	// The value of the JSONPath that is used for extracting part of the matched event
                                                                                                              	// when passing it to the target. You must use JSON dot notation, not bracket
                                                                                                              	// notation. For more information about JSON paths, see JSONPath
                                                                                                              	// (http://goessner.net/articles/JsonPath/).
                                                                                                              	InputPath *string
                                                                                                              
                                                                                                              	// Settings to enable you to provide custom input to a target based on certain
                                                                                                              	// event data. You can extract one or more key-value pairs from the event and then
                                                                                                              	// use that data to send customized input to the target.
                                                                                                              	InputTransformer *InputTransformer
                                                                                                              
                                                                                                              	// The custom parameter you can use to control the shard assignment, when the
                                                                                                              	// target is a Kinesis data stream. If you do not include this parameter, the
                                                                                                              	// default is to use the eventId as the partition key.
                                                                                                              	KinesisParameters *KinesisParameters
                                                                                                              
                                                                                                              	// Contains the Redshift Data API parameters to use when the target is a Redshift
                                                                                                              	// cluster. If you specify a Redshift Cluster as a Target, you can use this to
                                                                                                              	// specify parameters to invoke the Redshift Data API ExecuteStatement based on
                                                                                                              	// EventBridge events.
                                                                                                              	RedshiftDataParameters *RedshiftDataParameters
                                                                                                              
                                                                                                              	// The RetryPolicy object that contains the retry policy configuration to use for
                                                                                                              	// the dead-letter queue.
                                                                                                              	RetryPolicy *RetryPolicy
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the IAM role to be used for this target when
                                                                                                              	// the rule is triggered. If one rule triggers multiple targets, you can use a
                                                                                                              	// different IAM role for each target.
                                                                                                              	RoleArn *string
                                                                                                              
                                                                                                              	// Parameters used when you are using the rule to invoke Amazon EC2 Run Command.
                                                                                                              	RunCommandParameters *RunCommandParameters
                                                                                                              
                                                                                                              	// Contains the message group ID to use when the target is a FIFO queue. If you
                                                                                                              	// specify an SQS FIFO queue as a target, the queue must have content-based
                                                                                                              	// deduplication enabled.
                                                                                                              	SqsParameters *SqsParameters
                                                                                                              }

                                                                                                                Targets are the resources to be invoked when a rule is triggered. For a complete list of services and resources that can be set as a target, see PutTargets. If you are setting the event bus of another account as the target, and that account granted permission to your account through an organization instead of directly by the account ID, then you must specify a RoleArn with proper permissions in the Target structure. For more information, see Sending and Receiving Events Between AWS Accounts (https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-cross-account-event-delivery.html) in the Amazon EventBridge User Guide.