types

type ApiDestination struct {

	// The ARN of the API destination.
	ApiDestinationArn *string

	// The state of the API destination.
	ApiDestinationState ApiDestinationState

	// The ARN of the connection specified for the API destination.
	ConnectionArn *string

	// A time stamp for the time that the API destination was created.
	CreationTime *time.Time

	// The method to use to connect to the HTTP endpoint.
	HttpMethod ApiDestinationHttpMethod

	// The URL to the endpoint for the API destination.
	InvocationEndpoint *string

	// The maximum number of invocations per second to send to the HTTP endpoint.
	InvocationRateLimitPerSecond *int32

	// A time stamp for the time that the API destination was last modified.
	LastModifiedTime *time.Time

	// The name of the API destination.
	Name *string
	// contains filtered or unexported fields
}

type ApiDestinationHttpMethod string

type ApiDestinationState string

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
	// contains filtered or unexported fields
}

type ArchiveState string

type AssignPublicIp string

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type BatchParameters struct {

	// The ARN or name of the job definition to use if the event target is an 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 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
	// Batch job.
	ArrayProperties *BatchArrayProperties

	// The retry strategy to use for failed jobs, if the target is an 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
	// contains filtered or unexported fields
}

type BatchRetryStrategy struct {

	// The number of times to attempt to retry, if the job fails. Valid values are
	// 1–10.
	Attempts int32
	// contains filtered or unexported fields
}

type CapacityProviderStrategyItem struct {

	// The short name of the capacity provider.
	//
	// This member is required.
	CapacityProvider *string

	// The base value designates how many tasks, at a minimum, to run on the specified
	// capacity provider. Only one capacity provider in a capacity provider strategy
	// can have a base defined. If no value is specified, the default value of 0 is
	// used.
	Base int32

	// The weight value designates the relative percentage of the total number of
	// tasks launched that should use the specified capacity provider. The weight value
	// is taken into consideration after the base value, if defined, is satisfied.
	Weight int32
	// contains filtered or unexported fields
}

type ConcurrentModificationException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type Connection struct {

	// The authorization type specified for the connection.
	AuthorizationType ConnectionAuthorizationType

	// The ARN of the connection.
	ConnectionArn *string

	// The state of the connection.
	ConnectionState ConnectionState

	// A time stamp for the time that the connection was created.
	CreationTime *time.Time

	// A time stamp for the time that the connection was last authorized.
	LastAuthorizedTime *time.Time

	// A time stamp for the time that the connection was last modified.
	LastModifiedTime *time.Time

	// The name of the connection.
	Name *string

	// The reason that the connection is in the connection state.
	StateReason *string
	// contains filtered or unexported fields
}

type ConnectionApiKeyAuthResponseParameters struct {

	// The name of the header to use for the APIKeyValue used for authorization.
	ApiKeyName *string
	// contains filtered or unexported fields
}

type ConnectionAuthResponseParameters struct {

	// The API Key parameters to use for authorization.
	ApiKeyAuthParameters *ConnectionApiKeyAuthResponseParameters

	// The authorization parameters for Basic authorization.
	BasicAuthParameters *ConnectionBasicAuthResponseParameters

	// Additional parameters for the connection that are passed through with every
	// invocation to the HTTP endpoint.
	InvocationHttpParameters *ConnectionHttpParameters

	// The OAuth parameters to use for authorization.
	OAuthParameters *ConnectionOAuthResponseParameters
	// contains filtered or unexported fields
}

type ConnectionAuthorizationType string

type ConnectionBasicAuthResponseParameters struct {

	// The user name to use for Basic authorization.
	Username *string
	// contains filtered or unexported fields
}

type ConnectionBodyParameter struct {

	// Specified whether the value is secret.
	IsValueSecret bool

	// The key for the parameter.
	Key *string

	// The value associated with the key.
	Value *string
	// contains filtered or unexported fields
}

type ConnectionHeaderParameter struct {

	// Specified whether the value is a secret.
	IsValueSecret bool

	// The key for the parameter.
	Key *string

	// The value associated with the key.
	Value *string
	// contains filtered or unexported fields
}

type ConnectionHttpParameters struct {

	// Contains additional body string parameters for the connection.
	BodyParameters []ConnectionBodyParameter

	// Contains additional header parameters for the connection.
	HeaderParameters []ConnectionHeaderParameter

	// Contains additional query string parameters for the connection.
	QueryStringParameters []ConnectionQueryStringParameter
	// contains filtered or unexported fields
}

type ConnectionOAuthClientResponseParameters struct {

	// The client ID associated with the response to the connection request.
	ClientID *string
	// contains filtered or unexported fields
}

type ConnectionOAuthHttpMethod string

type ConnectionOAuthResponseParameters struct {

	// The URL to the HTTP endpoint that authorized the request.
	AuthorizationEndpoint *string

	// A ConnectionOAuthClientResponseParameters object that contains details about
	// the client parameters returned when OAuth is specified as the authorization
	// type.
	ClientParameters *ConnectionOAuthClientResponseParameters

	// The method used to connect to the HTTP endpoint.
	HttpMethod ConnectionOAuthHttpMethod

	// The additional HTTP parameters used for the OAuth authorization request.
	OAuthHttpParameters *ConnectionHttpParameters
	// contains filtered or unexported fields
}

type ConnectionQueryStringParameter struct {

	// Specifies whether the value is secret.
	IsValueSecret bool

	// The key for a query string parameter.
	Key *string

	// The value associated with the key for the query string parameter.
	Value *string
	// contains filtered or unexported fields
}

type ConnectionState string

type CreateConnectionApiKeyAuthRequestParameters struct {

	// The name of the API key to use for authorization.
	//
	// This member is required.
	ApiKeyName *string

	// The value for the API key to use for authorization.
	//
	// This member is required.
	ApiKeyValue *string
	// contains filtered or unexported fields
}

type CreateConnectionAuthRequestParameters struct {

	// A CreateConnectionApiKeyAuthRequestParameters object that contains the API key
	// authorization parameters to use for the connection.
	ApiKeyAuthParameters *CreateConnectionApiKeyAuthRequestParameters

	// A CreateConnectionBasicAuthRequestParameters object that contains the Basic
	// authorization parameters to use for the connection.
	BasicAuthParameters *CreateConnectionBasicAuthRequestParameters

	// A ConnectionHttpParameters object that contains the API key authorization
	// parameters to use for the connection. Note that if you include additional
	// parameters for the target of a rule via HttpParameters , including query
	// strings, the parameters added for the connection take precedence.
	InvocationHttpParameters *ConnectionHttpParameters

	// A CreateConnectionOAuthRequestParameters object that contains the OAuth
	// authorization parameters to use for the connection.
	OAuthParameters *CreateConnectionOAuthRequestParameters
	// contains filtered or unexported fields
}

type CreateConnectionBasicAuthRequestParameters struct {

	// The password associated with the user name to use for Basic authorization.
	//
	// This member is required.
	Password *string

	// The user name to use for Basic authorization.
	//
	// This member is required.
	Username *string
	// contains filtered or unexported fields
}

type CreateConnectionOAuthClientRequestParameters struct {

	// The client ID to use for OAuth authorization for the connection.
	//
	// This member is required.
	ClientID *string

	// The client secret associated with the client ID to use for OAuth authorization
	// for the connection.
	//
	// This member is required.
	ClientSecret *string
	// contains filtered or unexported fields
}

type CreateConnectionOAuthRequestParameters struct {

	// The URL to the authorization endpoint when OAuth is specified as the
	// authorization type.
	//
	// This member is required.
	AuthorizationEndpoint *string

	// A CreateConnectionOAuthClientRequestParameters object that contains the client
	// parameters for OAuth authorization.
	//
	// This member is required.
	ClientParameters *CreateConnectionOAuthClientRequestParameters

	// The method to use for the authorization request.
	//
	// This member is required.
	HttpMethod ConnectionOAuthHttpMethod

	// A ConnectionHttpParameters object that contains details about the additional
	// parameters to use for the connection.
	OAuthHttpParameters *ConnectionHttpParameters
	// contains filtered or unexported fields
}

type DeadLetterConfig struct {

	// The ARN of the SQS queue specified as the target for the dead-letter queue.
	Arn *string
	// contains filtered or unexported fields
}

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

	// The capacity provider strategy to use for the task. If a
	// capacityProviderStrategy is specified, the launchType parameter must be
	// omitted. If no capacityProviderStrategy or launchType is specified, the
	// defaultCapacityProviderStrategy for the cluster is used.
	CapacityProviderStrategy []CapacityProviderStrategyItem

	// Specifies whether to enable Amazon ECS managed tags for the task. For more
	// information, see Tagging Your Amazon ECS Resources (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html)
	// in the Amazon Elastic Container Service Developer Guide.
	EnableECSManagedTags bool

	// Whether or not to enable the execute command functionality for the containers
	// in this task. If true, this enables execute command functionality on all
	// containers in the task.
	EnableExecuteCommand bool

	// 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 Fargate
	// witt Amazon ECS is supported. For more information, see 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 Amazon 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

	// An array of placement constraint objects to use for the task. You can specify
	// up to 10 constraints per task (including constraints in the task definition and
	// those specified at runtime).
	PlacementConstraints []PlacementConstraint

	// The placement strategy objects to use for the task. You can specify a maximum
	// of five strategy rules per task.
	PlacementStrategy []PlacementStrategy

	// 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
	// Fargate Platform Versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
	// in the Amazon Elastic Container Service Developer Guide.
	PlatformVersion *string

	// Specifies whether to propagate the tags from the task definition to the task.
	// If no value is specified, the tags are not propagated. Tags can only be
	// propagated to the task during task creation. To add tags to a task after task
	// creation, use the TagResource API action.
	PropagateTags PropagateTags

	// The reference ID to use for the task.
	ReferenceId *string

	// The metadata that you apply to the task to help you categorize and organize
	// them. Each tag consists of a key and an optional value, both of which you
	// define. To learn more, see RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html#ECS-RunTask-request-tags)
	// in the Amazon ECS API Reference.
	Tags []Tag

	// The number of tasks to create based on TaskDefinition . The default is 1.
	TaskCount *int32
	// contains filtered or unexported fields
}

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 Amazon Web
	// Services accounts can write events to this event bus.
	Policy *string
	// contains filtered or unexported fields
}

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 Amazon Web Services
	// 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
	// contains filtered or unexported fields
}

type EventSourceState string

type HttpParameters struct {

	// The headers that need to be sent as part of request invoking the API Gateway
	// REST API or EventBridge ApiDestination.
	HeaderParameters map[string]string

	// The path parameter values to be used to populate API Gateway REST API or
	// EventBridge ApiDestination path wildcards ("*").
	PathParameterValues []string

	// The query string keys/values that need to be sent as part of request invoking
	// the API Gateway REST API or EventBridge ApiDestination.
	QueryStringParameters map[string]string
	// contains filtered or unexported fields
}

type IllegalStatusException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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.
	// 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 \"\""
	// } The InputTemplate can also be valid JSON with varibles in quotes or out, as
	// in the following example: "InputTransformer":
	//     {
	//
	//     "InputPathsMap": {"instance": "$.detail.instance","status":
	//     "$.detail.status"},
	//
	//     "InputTemplate": '{"myInstance": ,"myStatus": " 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 100 key-value pairs. You must use JSON dot
	// notation, not bracket notation. The keys cannot start with "Amazon Web
	// Services."
	InputPathsMap map[string]string
	// contains filtered or unexported fields
}

type InternalException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type InvalidEventPatternException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type InvalidStateException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type LaunchType string

type LimitExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ManagedRuleException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type OperationDisabledException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type PartnerEventSource struct {

	// The ARN of the partner event source.
	Arn *string

	// The name of the partner event source.
	Name *string
	// contains filtered or unexported fields
}

type PartnerEventSourceAccount struct {

	// The Amazon Web Services 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 Amazon Web Services
	// 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
	// contains filtered or unexported fields
}

type PlacementConstraint struct {

	// A cluster query language expression to apply to the constraint. You cannot
	// specify an expression if the constraint type is distinctInstance . To learn
	// more, see Cluster Query Language (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html)
	// in the Amazon Elastic Container Service Developer Guide.
	Expression *string

	// The type of constraint. Use distinctInstance to ensure that each task in a
	// particular group is running on a different container instance. Use memberOf to
	// restrict the selection to a group of valid candidates.
	Type PlacementConstraintType
	// contains filtered or unexported fields
}

type PlacementConstraintType string

type PlacementStrategy struct {

	// The field to apply the placement strategy against. For the spread placement
	// strategy, valid values are instanceId (or host, which has the same effect), or
	// any platform or custom attribute that is applied to a container instance, such
	// as attribute:ecs.availability-zone. For the binpack placement strategy, valid
	// values are cpu and memory. For the random placement strategy, this field is not
	// used.
	Field *string

	// The type of placement strategy. The random placement strategy randomly places
	// tasks on available candidates. The spread placement strategy spreads placement
	// across available candidates evenly based on the field parameter. The binpack
	// strategy places tasks on available candidates that have the least available
	// amount of the resource that is specified with the field parameter. For example,
	// if you binpack on memory, a task is placed on the instance with the least amount
	// of remaining memory (but still enough to run the task).
	Type PlacementStrategyType
	// contains filtered or unexported fields
}

type PlacementStrategyType string

type PolicyLengthExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type PropagateTags string

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

	// Amazon Web Services 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 (https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html)
	// call is used.
	Time *time.Time

	// An X-Ray trade header, which is an http header (X-Amzn-Trace-Id) that contains
	// the trace-id associated with the event. To learn more about X-Ray trace headers,
	// see Tracing header (https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-tracingheader)
	// in the X-Ray Developer Guide.
	TraceHeader *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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

	// Amazon Web Services 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 entry.
	Source *string

	// The date and time of the event.
	Time *time.Time
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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 Amazon Web Services 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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type ReplayState string

type ResourceAlreadyExistsException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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 Amazon Web Services
	// 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.
	// If you're setting an event bus in another account as the target and that account
	// granted permission to your account through an organization instead of directly
	// by the account ID, you must specify a RoleArn with proper permissions in the
	// Target structure, instead of here in this parameter.
	RoleArn *string

	// The scheduling expression. For example, "cron(0 20 * * ? *)", "rate(5
	// minutes)". For more information, see Creating an Amazon EventBridge rule that
	// runs on a schedule (https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html)
	// .
	ScheduleExpression *string

	// The state of the rule.
	State RuleState
	// contains filtered or unexported fields
}

type RuleState string

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type SageMakerPipelineParameter struct {

	// Name of parameter to start execution of a SageMaker Model Building Pipeline.
	//
	// This member is required.
	Name *string

	// Value of parameter to start execution of a SageMaker Model Building Pipeline.
	//
	// This member is required.
	Value *string
	// contains filtered or unexported fields
}

type SageMakerPipelineParameters struct {

	// List of Parameter names and values for SageMaker Model Building Pipeline
	// execution.
	PipelineParameterList []SageMakerPipelineParameter
	// contains filtered or unexported fields
}

type SqsParameters struct {

	// The FIFO message group ID to use as the target.
	MessageGroupId *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type Target struct {

	// The Amazon Resource Name (ARN) of the target.
	//
	// This member is required.
	Arn *string

	// The ID of the target. We recommend using a memorable and unique string.
	//
	// This member is required.
	Id *string

	// If the event target is an 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 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 or EventBridge ApiDestination. If you specify an API Gateway REST API
	// or EventBridge ApiDestination as a target, you can use this parameter to specify
	// headers, path parameters, and query string keys/values as part of your target
	// invoking request. If you're using ApiDestinations, the corresponding Connection
	// can also have these values configured. In case of any conflicting keys, values
	// from the Connection take precedence.
	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 Amazon Redshift Data API parameters to use when the target is a
	// Amazon Redshift cluster. If you specify a Amazon Redshift Cluster as a Target,
	// you can use this to specify parameters to invoke the Amazon 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 SageMaker Model Building Pipeline parameters to start execution of
	// a SageMaker Model Building Pipeline. If you specify a SageMaker Model Building
	// Pipeline as a target, you can use this to specify parameters to start a pipeline
	// execution based on EventBridge events.
	SageMakerPipelineParameters *SageMakerPipelineParameters

	// 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
	// contains filtered or unexported fields
}

type UpdateConnectionApiKeyAuthRequestParameters struct {

	// The name of the API key to use for authorization.
	ApiKeyName *string

	// The value associated with teh API key to use for authorization.
	ApiKeyValue *string
	// contains filtered or unexported fields
}

type UpdateConnectionAuthRequestParameters struct {

	// A UpdateConnectionApiKeyAuthRequestParameters object that contains the
	// authorization parameters for API key authorization.
	ApiKeyAuthParameters *UpdateConnectionApiKeyAuthRequestParameters

	// A UpdateConnectionBasicAuthRequestParameters object that contains the
	// authorization parameters for Basic authorization.
	BasicAuthParameters *UpdateConnectionBasicAuthRequestParameters

	// A ConnectionHttpParameters object that contains the additional parameters to
	// use for the connection.
	InvocationHttpParameters *ConnectionHttpParameters

	// A UpdateConnectionOAuthRequestParameters object that contains the authorization
	// parameters for OAuth authorization.
	OAuthParameters *UpdateConnectionOAuthRequestParameters
	// contains filtered or unexported fields
}

type UpdateConnectionBasicAuthRequestParameters struct {

	// The password associated with the user name to use for Basic authorization.
	Password *string

	// The user name to use for Basic authorization.
	Username *string
	// contains filtered or unexported fields
}

type UpdateConnectionOAuthClientRequestParameters struct {

	// The client ID to use for OAuth authorization.
	ClientID *string

	// The client secret assciated with the client ID to use for OAuth authorization.
	ClientSecret *string
	// contains filtered or unexported fields
}

type UpdateConnectionOAuthRequestParameters struct {

	// The URL to the authorization endpoint when OAuth is specified as the
	// authorization type.
	AuthorizationEndpoint *string

	// A UpdateConnectionOAuthClientRequestParameters object that contains the client
	// parameters to use for the connection when OAuth is specified as the
	// authorization type.
	ClientParameters *UpdateConnectionOAuthClientRequestParameters

	// The method used to connect to the HTTP endpoint.
	HttpMethod ConnectionOAuthHttpMethod

	// The additional HTTP parameters used for the OAuth authorization request.
	OAuthHttpParameters *ConnectionHttpParameters
	// contains filtered or unexported fields
}