v1alpha1

type AWSVPCConfiguration struct {
	AssignPublicIP *string `json:"assignPublicIP,omitempty"`
	// Reference field for SecurityGroups
	SecurityGroupRefs []*ackv1alpha1.AWSResourceReferenceWrapper `json:"securityGroupRefs,omitempty"`
	SecurityGroups    []*string                                  `json:"securityGroups,omitempty"`
	// Reference field for Subnets
	SubnetRefs []*ackv1alpha1.AWSResourceReferenceWrapper `json:"subnetRefs,omitempty"`
	Subnets    []*string                                  `json:"subnets,omitempty"`
}

type AcceleratorCountRequest struct {
	Max *int64 `json:"max,omitempty"`
	Min *int64 `json:"min,omitempty"`
}

type AcceleratorManufacturer string

type AcceleratorName string

type AcceleratorTotalMemoryMiBRequest struct {
	Max *int64 `json:"max,omitempty"`
	Min *int64 `json:"min,omitempty"`
}

type AcceleratorType string

type AccessType string

type AdvancedConfiguration struct {
	AlternateTargetGroupARN *string `json:"alternateTargetGroupARN,omitempty"`
	ProductionListenerRule  *string `json:"productionListenerRule,omitempty"`
	RoleARN                 *string `json:"roleARN,omitempty"`
	TestListenerRule        *string `json:"testListenerRule,omitempty"`
}

type AgentUpdateStatus string

type ApplicationProtocol string

type AssignPublicIP string

type Attachment struct {
	Details []*KeyValuePair `json:"details,omitempty"`
	ID      *string         `json:"id,omitempty"`
	Status  *string         `json:"status,omitempty"`
	Type    *string         `json:"type,omitempty"`
}

type AttachmentStateChange struct {
	AttachmentARN *string `json:"attachmentARN,omitempty"`
	Status        *string `json:"status,omitempty"`
}

type Attribute struct {
	Name       *string `json:"name,omitempty"`
	TargetID   *string `json:"targetID,omitempty"`
	TargetType *string `json:"targetType,omitempty"`
	Value      *string `json:"value,omitempty"`
}

type AutoRepairActionsStatus string

type AutoRepairConfiguration struct {
	ActionsStatus *string `json:"actionsStatus,omitempty"`
}

type AutoScalingGroupProvider struct {
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable once set"
	AutoScalingGroupARN *string `json:"autoScalingGroupARN,omitempty"`
	// Reference field for AutoScalingGroupARN
	AutoScalingGroupRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"autoScalingGroupRef,omitempty"`
	ManagedDraining     *string                                  `json:"managedDraining,omitempty"`
	// The managed scaling settings for the Auto Scaling group capacity provider.
	//
	// When managed scaling is turned on, Amazon ECS manages the scale-in and scale-out
	// actions of the Auto Scaling group. Amazon ECS manages a target tracking scaling
	// policy using an Amazon ECS managed CloudWatch metric with the specified targetCapacity
	// value as the target value for the metric. For more information, see Using
	// managed scaling (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// If managed scaling is off, the user must manage the scaling of the Auto Scaling
	// group.
	ManagedScaling               *ManagedScaling `json:"managedScaling,omitempty"`
	ManagedTerminationProtection *string         `json:"managedTerminationProtection,omitempty"`
}

type AutoScalingGroupProviderUpdate struct {
	ManagedDraining *string `json:"managedDraining,omitempty"`
	// The managed scaling settings for the Auto Scaling group capacity provider.
	//
	// When managed scaling is turned on, Amazon ECS manages the scale-in and scale-out
	// actions of the Auto Scaling group. Amazon ECS manages a target tracking scaling
	// policy using an Amazon ECS managed CloudWatch metric with the specified targetCapacity
	// value as the target value for the metric. For more information, see Using
	// managed scaling (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/asg-capacity-providers.html#asg-capacity-providers-managed-scaling)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// If managed scaling is off, the user must manage the scaling of the Auto Scaling
	// group.
	ManagedScaling               *ManagedScaling `json:"managedScaling,omitempty"`
	ManagedTerminationProtection *string         `json:"managedTerminationProtection,omitempty"`
}

type AvailabilityZoneRebalancing string

type BareMetal string

type BaselineEBSBandwidthMbpsRequest struct {
	Max *int64 `json:"max,omitempty"`
	Min *int64 `json:"min,omitempty"`
}

type BurstablePerformance string

type CPUArchitecture string

type CPUManufacturer string

type CanaryConfiguration struct {
	CanaryBakeTimeInMinutes *int64   `json:"canaryBakeTimeInMinutes,omitempty"`
	CanaryPercent           *float64 `json:"canaryPercent,omitempty"`
}

type CapacityOptionType string

type CapacityProvider struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              CapacityProviderSpec   `json:"spec,omitempty"`
	Status            CapacityProviderStatus `json:"status,omitempty"`
}

type CapacityProviderField string

type CapacityProviderList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []CapacityProvider `json:"items"`
}

type CapacityProviderSpec struct {

	// The details of the Auto Scaling group for the capacity provider.
	AutoScalingGroupProvider *AutoScalingGroupProvider `json:"autoScalingGroupProvider,omitempty"`
	// The name of the cluster to associate with the capacity provider. When you
	// create a capacity provider with Amazon ECS Managed Instances, it becomes
	// available only within the specified cluster.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable once set"
	Cluster    *string                                  `json:"cluster,omitempty"`
	ClusterRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"clusterRef,omitempty"`
	// The configuration for the Amazon ECS Managed Instances provider. This configuration
	// specifies how Amazon ECS manages Amazon EC2 instances on your behalf, including
	// the infrastructure role, instance launch template, and tag propagation settings.
	ManagedInstancesProvider *CreateManagedInstancesProviderConfiguration `json:"managedInstancesProvider,omitempty"`
	// The name of the capacity provider. Up to 255 characters are allowed. They
	// include letters (both upper and lowercase letters), numbers, underscores
	// (_), and hyphens (-). The name can't be prefixed with "aws", "ecs", or "fargate".
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Value is immutable once set"
	// +kubebuilder:validation:Required
	Name *string `json:"name"`
	// The metadata that you apply to the capacity provider to categorize and organize
	// them more conveniently. Each tag consists of a key and an optional value.
	// You define both of them.
	//
	// The following basic restrictions apply to tags:
	//
	//   - Maximum number of tags per resource - 50
	//
	//   - For each resource, each tag key must be unique, and each tag key can
	//     have only one value.
	//
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//
	//   - If your tagging schema is used across multiple services and resources,
	//     remember that other services may have restrictions on allowed characters.
	//     Generally allowed characters are: letters, numbers, and spaces representable
	//     in UTF-8, and the following characters: + - = . _ : / @.
	//
	//   - Tag keys and values are case-sensitive.
	//
	//   - Do not use aws:, AWS:, or any upper or lowercase combination of such
	//     as a prefix for either keys or values as it is reserved for Amazon Web
	//     Services use. You cannot edit or delete tag keys or values with this prefix.
	//     Tags with this prefix do not count against your tags per resource limit.
	Tags []*Tag `json:"tags,omitempty"`
}

type CapacityProviderStatus struct {
	// All CRs managed by ACK have a common `Status.ACKResourceMetadata` member
	// that is used to contain resource sync state, account ownership,
	// constructed ARN for the resource
	// +kubebuilder:validation:Optional
	ACKResourceMetadata *ackv1alpha1.ResourceMetadata `json:"ackResourceMetadata"`
	// All CRs managed by ACK have a common `Status.Conditions` member that
	// contains a collection of `ackv1alpha1.Condition` objects that describe
	// the various terminal states of the CR and its backend AWS service API
	// resource
	// +kubebuilder:validation:Optional
	Conditions []*ackv1alpha1.Condition `json:"conditions"`
	// The current status of the capacity provider. Only capacity providers in an
	// ACTIVE state can be used in a cluster. When a capacity provider is successfully
	// deleted, it has an INACTIVE status.
	// +kubebuilder:validation:Optional
	Status *string `json:"status,omitempty"`
	// The type of capacity provider. For Amazon ECS Managed Instances, this value
	// is MANAGED_INSTANCES, indicating that Amazon ECS manages the underlying Amazon
	// EC2 instances on your behalf.
	// +kubebuilder:validation:Optional
	Type *string `json:"type,omitempty"`
	// The update status of the capacity provider. The following are the possible
	// states that is returned.
	//
	// DELETE_IN_PROGRESS
	//
	// The capacity provider is in the process of being deleted.
	//
	// DELETE_COMPLETE
	//
	// The capacity provider was successfully deleted and has an INACTIVE status.
	//
	// DELETE_FAILED
	//
	// The capacity provider can't be deleted. The update status reason provides
	// further details about why the delete failed.
	// +kubebuilder:validation:Optional
	UpdateStatus *string `json:"updateStatus,omitempty"`
	// The update status reason. This provides further details about the update
	// status for the capacity provider.
	// +kubebuilder:validation:Optional
	UpdateStatusReason *string `json:"updateStatusReason,omitempty"`
}

type CapacityProviderStatus_SDK string

type CapacityProviderStrategyItem struct {
	Base             *int64  `json:"base,omitempty"`
	CapacityProvider *string `json:"capacityProvider,omitempty"`
	Weight           *int64  `json:"weight,omitempty"`
}

type CapacityProviderType string

type CapacityProviderUpdateStatus string

type CapacityProvider_SDK struct {
	// The details of the Auto Scaling group for the capacity provider.
	AutoScalingGroupProvider *AutoScalingGroupProvider `json:"autoScalingGroupProvider,omitempty"`
	CapacityProviderARN      *string                   `json:"capacityProviderARN,omitempty"`
	Cluster                  *string                   `json:"cluster,omitempty"`
	// The configuration for a Amazon ECS Managed Instances provider. Amazon ECS
	// uses this configuration to automatically launch, manage, and terminate Amazon
	// EC2 instances on your behalf. Managed instances provide access to the full
	// range of Amazon EC2 instance types and features while offloading infrastructure
	// management to Amazon Web Services.
	ManagedInstancesProvider *ManagedInstancesProvider `json:"managedInstancesProvider,omitempty"`
	Name                     *string                   `json:"name,omitempty"`
	Status                   *string                   `json:"status,omitempty"`
	Tags                     []*Tag                    `json:"tags,omitempty"`
	Type                     *string                   `json:"type_,omitempty"`
	UpdateStatus             *string                   `json:"updateStatus,omitempty"`
	UpdateStatusReason       *string                   `json:"updateStatusReason,omitempty"`
}

type CapacityReservationPreference string

type CapacityReservationRequest struct {
	ReservationGroupARN   *string `json:"reservationGroupARN,omitempty"`
	ReservationPreference *string `json:"reservationPreference,omitempty"`
}

type Cluster struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              ClusterSpec   `json:"spec,omitempty"`
	Status            ClusterStatus `json:"status,omitempty"`
}

type ClusterConfiguration struct {
	// The details of the execute command configuration.
	ExecuteCommandConfiguration *ExecuteCommandConfiguration `json:"executeCommandConfiguration,omitempty"`
}

type ClusterField string

type ClusterList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Cluster `json:"items"`
}

type ClusterServiceConnectDefaults struct {
	Namespace *string `json:"namespace,omitempty"`
}

type ClusterServiceConnectDefaultsRequest struct {
	Namespace *string `json:"namespace,omitempty"`
}

type ClusterSetting struct {
	Name  *string `json:"name,omitempty"`
	Value *string `json:"value,omitempty"`
}

type ClusterSettingName string

type ClusterSpec struct {

	// The short name of one or more capacity providers to associate with the cluster.
	// A capacity provider must be associated with a cluster before it can be included
	// as part of the default capacity provider strategy of the cluster or used
	// in a capacity provider strategy when calling the CreateService (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)
	// or RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)
	// actions.
	//
	// If specifying a capacity provider that uses an Auto Scaling group, the capacity
	// provider must be created but not associated with another cluster. New Auto
	// Scaling group capacity providers can be created with the CreateCapacityProvider
	// (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html)
	// API operation.
	//
	// To use a Fargate capacity provider, specify either the FARGATE or FARGATE_SPOT
	// capacity providers. The Fargate capacity providers are available to all accounts
	// and only need to be associated with a cluster to be used.
	//
	// The PutCapacityProvider (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html)
	// API operation is used to update the list of available capacity providers
	// for a cluster after the cluster is created.
	CapacityProviders []*string `json:"capacityProviders,omitempty"`
	// The execute command configuration for the cluster.
	Configuration *ClusterConfiguration `json:"configuration,omitempty"`
	// The capacity provider strategy to set as the default for the cluster. After
	// a default capacity provider strategy is set for a cluster, when you call
	// the CreateService (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html)
	// or RunTask (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html)
	// APIs with no capacity provider strategy or launch type specified, the default
	// capacity provider strategy for the cluster is used.
	//
	// If a default capacity provider strategy isn't defined for a cluster when
	// it was created, it can be defined later with the PutClusterCapacityProviders
	// (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutClusterCapacityProviders.html)
	// API operation.
	DefaultCapacityProviderStrategy []*CapacityProviderStrategyItem `json:"defaultCapacityProviderStrategy,omitempty"`
	// The name of your cluster. If you don't specify a name for your cluster, you
	// create a cluster that's named default. Up to 255 letters (uppercase and lowercase),
	// numbers, underscores, and hyphens are allowed.
	Name *string `json:"name,omitempty"`
	// Use this parameter to set a default Service Connect namespace. After you
	// set a default Service Connect namespace, any new services with Service Connect
	// turned on that are created in the cluster are added as client services in
	// the namespace. This setting only applies to new services that set the enabled
	// parameter to true in the ServiceConnectConfiguration. You can set the namespace
	// of each service individually in the ServiceConnectConfiguration to override
	// this default parameter.
	//
	// Tasks that run in a namespace can use short names to connect to services
	// in the namespace. Tasks can connect to services across all of the clusters
	// in the namespace. Tasks connect through a managed proxy container that collects
	// logs and metrics for increased visibility. Only the tasks that Amazon ECS
	// services create are supported with Service Connect. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectDefaults *ClusterServiceConnectDefaultsRequest `json:"serviceConnectDefaults,omitempty"`
	// The setting to use when creating a cluster. This parameter is used to turn
	// on CloudWatch Container Insights for a cluster. If this value is specified,
	// it overrides the containerInsights value set with PutAccountSetting (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSetting.html)
	// or PutAccountSettingDefault (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSettingDefault.html).
	Settings []*ClusterSetting `json:"settings,omitempty"`
	// The metadata that you apply to the cluster to help you categorize and organize
	// them. Each tag consists of a key and an optional value. You define both.
	//
	// The following basic restrictions apply to tags:
	//
	//   - Maximum number of tags per resource - 50
	//
	//   - For each resource, each tag key must be unique, and each tag key can
	//     have only one value.
	//
	//   - Maximum key length - 128 Unicode characters in UTF-8
	//
	//   - Maximum value length - 256 Unicode characters in UTF-8
	//
	//   - If your tagging schema is used across multiple services and resources,
	//     remember that other services may have restrictions on allowed characters.
	//     Generally allowed characters are: letters, numbers, and spaces representable
	//     in UTF-8, and the following characters: + - = . _ : / @.
	//
	//   - Tag keys and values are case-sensitive.
	//
	//   - Do not use aws:, AWS:, or any upper or lowercase combination of such
	//     as a prefix for either keys or values as it is reserved for Amazon Web
	//     Services use. You cannot edit or delete tag keys or values with this prefix.
	//     Tags with this prefix do not count against your tags per resource limit.
	Tags []*Tag `json:"tags,omitempty"`
}

type ClusterStatus struct {
	// All CRs managed by ACK have a common `Status.ACKResourceMetadata` member
	// that is used to contain resource sync state, account ownership,
	// constructed ARN for the resource
	// +kubebuilder:validation:Optional
	ACKResourceMetadata *ackv1alpha1.ResourceMetadata `json:"ackResourceMetadata"`
	// All CRs managed by ACK have a common `Status.Conditions` member that
	// contains a collection of `ackv1alpha1.Condition` objects that describe
	// the various terminal states of the CR and its backend AWS service API
	// resource
	// +kubebuilder:validation:Optional
	Conditions []*ackv1alpha1.Condition `json:"conditions"`
	// The number of services that are running on the cluster in an ACTIVE state.
	// You can view these services with ListServices (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ListServices.html).
	// +kubebuilder:validation:Optional
	ActiveServicesCount *int64 `json:"activeServicesCount,omitempty"`
	// The resources attached to a cluster. When using a capacity provider with
	// a cluster, the capacity provider and associated resources are returned as
	// cluster attachments.
	// +kubebuilder:validation:Optional
	Attachments []*Attachment `json:"attachments,omitempty"`
	// The status of the capacity providers associated with the cluster. The following
	// are the states that are returned.
	//
	// UPDATE_IN_PROGRESS
	//
	// The available capacity providers for the cluster are updating.
	//
	// UPDATE_COMPLETE
	//
	// The capacity providers have successfully updated.
	//
	// UPDATE_FAILED
	//
	// The capacity provider updates failed.
	// +kubebuilder:validation:Optional
	AttachmentsStatus *string `json:"attachmentsStatus,omitempty"`
	// The number of tasks in the cluster that are in the PENDING state.
	// +kubebuilder:validation:Optional
	PendingTasksCount *int64 `json:"pendingTasksCount,omitempty"`
	// The number of container instances registered into the cluster. This includes
	// container instances in both ACTIVE and DRAINING status.
	// +kubebuilder:validation:Optional
	RegisteredContainerInstancesCount *int64 `json:"registeredContainerInstancesCount,omitempty"`
	// The number of tasks in the cluster that are in the RUNNING state.
	// +kubebuilder:validation:Optional
	RunningTasksCount *int64 `json:"runningTasksCount,omitempty"`
	// Additional information about your clusters that are separated by launch type.
	// They include the following:
	//
	//    * runningEC2TasksCount
	//
	//    * RunningFargateTasksCount
	//
	//    * pendingEC2TasksCount
	//
	//    * pendingFargateTasksCount
	//
	//    * activeEC2ServiceCount
	//
	//    * activeFargateServiceCount
	//
	//    * drainingEC2ServiceCount
	//
	//    * drainingFargateServiceCount
	// +kubebuilder:validation:Optional
	Statistics []*KeyValuePair `json:"statistics,omitempty"`
	// The status of the cluster. The following are the possible states that are
	// returned.
	//
	// ACTIVE
	//
	// The cluster is ready to accept tasks and if applicable you can register container
	// instances with the cluster.
	//
	// PROVISIONING
	//
	// The cluster has capacity providers that are associated with it and the resources
	// needed for the capacity provider are being created.
	//
	// DEPROVISIONING
	//
	// The cluster has capacity providers that are associated with it and the resources
	// needed for the capacity provider are being deleted.
	//
	// FAILED
	//
	// The cluster has capacity providers that are associated with it and the resources
	// needed for the capacity provider have failed to create.
	//
	// INACTIVE
	//
	// The cluster has been deleted. Clusters with an INACTIVE status may remain
	// discoverable in your account for a period of time. However, this behavior
	// is subject to change in the future. We don't recommend that you rely on INACTIVE
	// clusters persisting.
	// +kubebuilder:validation:Optional
	Status *string `json:"status,omitempty"`
}

type Cluster_SDK struct {
	ActiveServicesCount *int64        `json:"activeServicesCount,omitempty"`
	Attachments         []*Attachment `json:"attachments,omitempty"`
	AttachmentsStatus   *string       `json:"attachmentsStatus,omitempty"`
	CapacityProviders   []*string     `json:"capacityProviders,omitempty"`
	ClusterARN          *string       `json:"clusterARN,omitempty"`
	ClusterName         *string       `json:"clusterName,omitempty"`
	// The execute command and managed storage configuration for the cluster.
	Configuration                     *ClusterConfiguration           `json:"configuration,omitempty"`
	DefaultCapacityProviderStrategy   []*CapacityProviderStrategyItem `json:"defaultCapacityProviderStrategy,omitempty"`
	PendingTasksCount                 *int64                          `json:"pendingTasksCount,omitempty"`
	RegisteredContainerInstancesCount *int64                          `json:"registeredContainerInstancesCount,omitempty"`
	RunningTasksCount                 *int64                          `json:"runningTasksCount,omitempty"`
	// Use this parameter to set a default Service Connect namespace. After you
	// set a default Service Connect namespace, any new services with Service Connect
	// turned on that are created in the cluster are added as client services in
	// the namespace. This setting only applies to new services that set the enabled
	// parameter to true in the ServiceConnectConfiguration. You can set the namespace
	// of each service individually in the ServiceConnectConfiguration to override
	// this default parameter.
	//
	// Tasks that run in a namespace can use short names to connect to services
	// in the namespace. Tasks can connect to services across all of the clusters
	// in the namespace. Tasks connect through a managed proxy container that collects
	// logs and metrics for increased visibility. Only the tasks that Amazon ECS
	// services create are supported with Service Connect. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectDefaults *ClusterServiceConnectDefaults `json:"serviceConnectDefaults,omitempty"`
	Settings               []*ClusterSetting              `json:"settings,omitempty"`
	Statistics             []*KeyValuePair                `json:"statistics,omitempty"`
	Status                 *string                        `json:"status,omitempty"`
	Tags                   []*Tag                         `json:"tags,omitempty"`
}

type Compatibility string

type Connectivity string

type Container struct {
	ContainerARN      *string `json:"containerARN,omitempty"`
	CPU               *string `json:"cpu,omitempty"`
	ExitCode          *int64  `json:"exitCode,omitempty"`
	Image             *string `json:"image,omitempty"`
	ImageDigest       *string `json:"imageDigest,omitempty"`
	LastStatus        *string `json:"lastStatus,omitempty"`
	Memory            *string `json:"memory,omitempty"`
	MemoryReservation *string `json:"memoryReservation,omitempty"`
	Name              *string `json:"name,omitempty"`
	Reason            *string `json:"reason,omitempty"`
	RuntimeID         *string `json:"runtimeID,omitempty"`
	TaskARN           *string `json:"taskARN,omitempty"`
}

type ContainerCondition string

type ContainerDefinition struct {
	Command               []*string              `json:"command,omitempty"`
	CPU                   *int64                 `json:"cpu,omitempty"`
	CredentialSpecs       []*string              `json:"credentialSpecs,omitempty"`
	DependsOn             []*ContainerDependency `json:"dependsOn,omitempty"`
	DisableNetworking     *bool                  `json:"disableNetworking,omitempty"`
	DNSSearchDomains      []*string              `json:"dnsSearchDomains,omitempty"`
	DNSServers            []*string              `json:"dnsServers,omitempty"`
	DockerLabels          map[string]*string     `json:"dockerLabels,omitempty"`
	DockerSecurityOptions []*string              `json:"dockerSecurityOptions,omitempty"`
	EntryPoint            []*string              `json:"entryPoint,omitempty"`
	Environment           []*KeyValuePair        `json:"environment,omitempty"`
	EnvironmentFiles      []*EnvironmentFile     `json:"environmentFiles,omitempty"`
	Essential             *bool                  `json:"essential,omitempty"`
	ExtraHosts            []*HostEntry           `json:"extraHosts,omitempty"`
	// The FireLens configuration for the container. This is used to specify and
	// configure a log router for container logs. For more information, see Custom
	// log routing (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
	// in the Amazon Elastic Container Service Developer Guide.
	FirelensConfiguration *FirelensConfiguration `json:"firelensConfiguration,omitempty"`
	// An object representing a container health check. Health check parameters
	// that are specified in a container definition override any Docker health checks
	// that exist in the container image (such as those specified in a parent image
	// or from the image's Dockerfile). This configuration maps to the HEALTHCHECK
	// parameter of docker run.
	//
	// The Amazon ECS container agent only monitors and reports on the health checks
	// specified in the task definition. Amazon ECS does not monitor Docker health
	// checks that are embedded in a container image and not specified in the container
	// definition. Health check parameters that are specified in a container definition
	// override any Docker health checks that exist in the container image.
	//
	// You can view the health status of both individual containers and a task with
	// the DescribeTasks API operation or when viewing the task details in the console.
	//
	// The health check is designed to make sure that your containers survive agent
	// restarts, upgrades, or temporary unavailability.
	//
	// Amazon ECS performs health checks on containers with the default that launched
	// the container instance or the task.
	//
	// The following describes the possible healthStatus values for a container:
	//
	//    * HEALTHY-The container health check has passed successfully.
	//
	//    * UNHEALTHY-The container health check has failed.
	//
	//    * UNKNOWN-The container health check is being evaluated, there's no container
	//    health check defined, or Amazon ECS doesn't have the health status of
	//    the container.
	//
	// The following describes the possible healthStatus values based on the container
	// health checker status of essential containers in the task with the following
	// priority order (high to low):
	//
	//    * UNHEALTHY-One or more essential containers have failed their health
	//    check.
	//
	//    * UNKNOWN-Any essential container running within the task is in an UNKNOWN
	//    state and no other essential containers have an UNHEALTHY state.
	//
	//    * HEALTHY-All essential containers within the task have passed their health
	//    checks.
	//
	// Consider the following task health example with 2 containers.
	//
	//    * If Container1 is UNHEALTHY and Container2 is UNKNOWN, the task health
	//    is UNHEALTHY.
	//
	//    * If Container1 is UNHEALTHY and Container2 is HEALTHY, the task health
	//    is UNHEALTHY.
	//
	//    * If Container1 is HEALTHY and Container2 is UNKNOWN, the task health
	//    is UNKNOWN.
	//
	//    * If Container1 is HEALTHY and Container2 is HEALTHY, the task health
	//    is HEALTHY.
	//
	// Consider the following task health example with 3 containers.
	//
	//    * If Container1 is UNHEALTHY and Container2 is UNKNOWN, and Container3
	//    is UNKNOWN, the task health is UNHEALTHY.
	//
	//    * If Container1 is UNHEALTHY and Container2 is UNKNOWN, and Container3
	//    is HEALTHY, the task health is UNHEALTHY.
	//
	//    * If Container1 is UNHEALTHY and Container2 is HEALTHY, and Container3
	//    is HEALTHY, the task health is UNHEALTHY.
	//
	//    * If Container1 is HEALTHY and Container2 is UNKNOWN, and Container3 is
	//    HEALTHY, the task health is UNKNOWN.
	//
	//    * If Container1 is HEALTHY and Container2 is UNKNOWN, and Container3 is
	//    UNKNOWN, the task health is UNKNOWN.
	//
	//    * If Container1 is HEALTHY and Container2 is HEALTHY, and Container3 is
	//    HEALTHY, the task health is HEALTHY.
	//
	// If a task is run manually, and not as part of a service, the task will continue
	// its lifecycle regardless of its health status. For tasks that are part of
	// a service, if the task reports as unhealthy then the task will be stopped
	// and the service scheduler will replace it.
	//
	// When a container health check fails for a task that is part of a service,
	// the following process occurs:
	//
	// The task is marked as UNHEALTHY.
	//
	// The unhealthy task will be stopped, and during the stopping process, it will
	// go through the following states:
	//
	//    * DEACTIVATING - In this state, Amazon ECS performs additional steps before
	//    stopping the task. For example, for tasks that are part of services configured
	//    to use Elastic Load Balancing target groups, target groups will be deregistered
	//    in this state.
	//
	//    * STOPPING - The task is in the process of being stopped.
	//
	//    * DEPROVISIONING - Resources associated with the task are being cleaned
	//    up.
	//
	//    * STOPPED - The task has been completely stopped.
	//
	// After the old task stops, a new task will be launched to ensure service operation,
	// and the new task will go through the following lifecycle:
	//
	//    * PROVISIONING - Resources required for the task are being provisioned.
	//
	//    * PENDING - The task is waiting to be placed on a container instance.
	//
	//    * ACTIVATING - In this state, Amazon ECS pulls container images, creates
	//    containers, configures task networking, registers load balancer target
	//    groups, and configures service discovery status.
	//
	//    * RUNNING - The task is running and performing its work.
	//
	// For more detailed information about task lifecycle states, see Task lifecycle
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle-explanation.html)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// The following are notes about container health check support:
	//
	//    * If the Amazon ECS container agent becomes disconnected from the Amazon
	//    ECS service, this won't cause a container to transition to an UNHEALTHY
	//    status. This is by design, to ensure that containers remain running during
	//    agent restarts or temporary unavailability. The health check status is
	//    the "last heard from" response from the Amazon ECS agent, so if the container
	//    was considered HEALTHY prior to the disconnect, that status will remain
	//    until the agent reconnects and another health check occurs. There are
	//    no assumptions made about the status of the container health checks.
	//
	//    * Container health checks require version 1.17.0 or greater of the Amazon
	//    ECS container agent. For more information, see Updating the Amazon ECS
	//    container agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).
	//
	//    * Container health checks are supported for Fargate tasks if you're using
	//    platform version 1.1.0 or greater. For more information, see Fargate platform
	//    versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).
	//
	//    * Container health checks aren't supported for tasks that are part of
	//    a service that's configured to use a Classic Load Balancer.
	//
	// For an example of how to specify a task definition with multiple containers
	// where container dependency is specified, see Container dependency (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/example_task_definitions.html#example_task_definition-containerdependency)
	// in the Amazon Elastic Container Service Developer Guide.
	HealthCheck *HealthCheck `json:"healthCheck,omitempty"`
	Hostname    *string      `json:"hostname,omitempty"`
	Image       *string      `json:"image,omitempty"`
	Interactive *bool        `json:"interactive,omitempty"`
	Links       []*string    `json:"links,omitempty"`
	// The Linux-specific options that are applied to the container, such as Linux
	// KernelCapabilities (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).
	LinuxParameters *LinuxParameters `json:"linuxParameters,omitempty"`
	// The log configuration for the container. This parameter maps to LogConfig
	// in the docker container create command and the --log-driver option to docker
	// run.
	//
	// By default, containers use the same logging driver that the Docker daemon
	// uses. However, the container might use a different logging driver than the
	// Docker daemon by specifying a log driver configuration in the container definition.
	//
	// Understand the following when specifying a log configuration for your containers.
	//
	//    * Amazon ECS currently supports a subset of the logging drivers available
	//    to the Docker daemon. Additional log drivers may be available in future
	//    releases of the Amazon ECS container agent. For tasks on Fargate, the
	//    supported log drivers are awslogs, splunk, and awsfirelens. For tasks
	//    hosted on Amazon EC2 instances, the supported log drivers are awslogs,
	//    fluentd, gelf, json-file, journald,syslog, splunk, and awsfirelens.
	//
	//    * This parameter requires version 1.18 of the Docker Remote API or greater
	//    on your container instance.
	//
	//    * For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container
	//    agent must register the available logging drivers with the ECS_AVAILABLE_LOGGING_DRIVERS
	//    environment variable before containers placed on that instance can use
	//    these log configuration options. For more information, see Amazon ECS
	//    container agent configuration (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	//    in the Amazon Elastic Container Service Developer Guide.
	//
	//    * For tasks that are on Fargate, because you don't have access to the
	//    underlying infrastructure your tasks are hosted on, any additional software
	//    needed must be installed outside of the task. For example, the Fluentd
	//    output aggregators or a remote host running Logstash to send Gelf logs
	//    to.
	LogConfiguration       *LogConfiguration `json:"logConfiguration,omitempty"`
	Memory                 *int64            `json:"memory,omitempty"`
	MemoryReservation      *int64            `json:"memoryReservation,omitempty"`
	MountPoints            []*MountPoint     `json:"mountPoints,omitempty"`
	Name                   *string           `json:"name,omitempty"`
	PortMappings           []*PortMapping    `json:"portMappings,omitempty"`
	Privileged             *bool             `json:"privileged,omitempty"`
	PseudoTerminal         *bool             `json:"pseudoTerminal,omitempty"`
	ReadonlyRootFilesystem *bool             `json:"readonlyRootFilesystem,omitempty"`
	// The repository credentials for private registry authentication.
	RepositoryCredentials *RepositoryCredentials `json:"repositoryCredentials,omitempty"`
	ResourceRequirements  []*ResourceRequirement `json:"resourceRequirements,omitempty"`
	Secrets               []*Secret              `json:"secrets,omitempty"`
	StartTimeout          *int64                 `json:"startTimeout,omitempty"`
	StopTimeout           *int64                 `json:"stopTimeout,omitempty"`
	SystemControls        []*SystemControl       `json:"systemControls,omitempty"`
	Ulimits               []*Ulimit              `json:"ulimits,omitempty"`
	User                  *string                `json:"user,omitempty"`
	VolumesFrom           []*VolumeFrom          `json:"volumesFrom,omitempty"`
	WorkingDirectory      *string                `json:"workingDirectory,omitempty"`
}

type ContainerDependency struct {
	Condition     *string `json:"condition,omitempty"`
	ContainerName *string `json:"containerName,omitempty"`
}

type ContainerImage struct {
	ContainerName *string `json:"containerName,omitempty"`
	Image         *string `json:"image,omitempty"`
	ImageDigest   *string `json:"imageDigest,omitempty"`
}

type ContainerInstance struct {
	AgentConnected       *bool         `json:"agentConnected,omitempty"`
	Attachments          []*Attachment `json:"attachments,omitempty"`
	CapacityProviderName *string       `json:"capacityProviderName,omitempty"`
	ContainerInstanceARN *string       `json:"containerInstanceARN,omitempty"`
	EC2InstanceID        *string       `json:"ec2InstanceID,omitempty"`
	PendingTasksCount    *int64        `json:"pendingTasksCount,omitempty"`
	RegisteredAt         *metav1.Time  `json:"registeredAt,omitempty"`
	RunningTasksCount    *int64        `json:"runningTasksCount,omitempty"`
	Status               *string       `json:"status,omitempty"`
	StatusReason         *string       `json:"statusReason,omitempty"`
	Tags                 []*Tag        `json:"tags,omitempty"`
}

type ContainerInstanceField string

type ContainerInstanceStatus string

type ContainerOverride struct {
	Command              []*string              `json:"command,omitempty"`
	CPU                  *int64                 `json:"cpu,omitempty"`
	Environment          []*KeyValuePair        `json:"environment,omitempty"`
	EnvironmentFiles     []*EnvironmentFile     `json:"environmentFiles,omitempty"`
	Memory               *int64                 `json:"memory,omitempty"`
	MemoryReservation    *int64                 `json:"memoryReservation,omitempty"`
	Name                 *string                `json:"name,omitempty"`
	ResourceRequirements []*ResourceRequirement `json:"resourceRequirements,omitempty"`
}

type ContainerStateChange struct {
	ContainerName *string `json:"containerName,omitempty"`
	ExitCode      *int64  `json:"exitCode,omitempty"`
	ImageDigest   *string `json:"imageDigest,omitempty"`
	Reason        *string `json:"reason,omitempty"`
	RuntimeID     *string `json:"runtimeID,omitempty"`
	Status        *string `json:"status,omitempty"`
}

type CreateManagedInstancesProviderConfiguration struct {
	// The auto repair configuration for an Amazon ECS Managed Instances capacity
	// provider. When enabled, Amazon ECS automatically replaces container instances
	// that are detected as unhealthy based on container instance health checks,
	// including accelerated compute device and daemon health checks.
	AutoRepairConfiguration *AutoRepairConfiguration `json:"autoRepairConfiguration,omitempty"`
	// The configuration that controls how Amazon ECS optimizes your infrastructure.
	InfrastructureOptimization *InfrastructureOptimization `json:"infrastructureOptimization,omitempty"`
	InfrastructureRoleARN      *string                     `json:"infrastructureRoleARN,omitempty"`
	// Reference field for InfrastructureRoleARN
	InfrastructureRoleRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"infrastructureRoleRef,omitempty"`
	// The launch template configuration for Amazon ECS Managed Instances. This
	// defines how Amazon ECS launches Amazon EC2 instances, including the instance
	// profile for your tasks, network and storage configuration, capacity options,
	// and instance requirements for flexible instance type selection.
	InstanceLaunchTemplate *InstanceLaunchTemplate `json:"instanceLaunchTemplate,omitempty"`
	PropagateTags          *string                 `json:"propagateTags,omitempty"`
}

type CreatedAt struct {
	After  *metav1.Time `json:"after,omitempty"`
	Before *metav1.Time `json:"before,omitempty"`
}

type DaemonAlarmConfiguration struct {
	AlarmNames []*string `json:"alarmNames,omitempty"`
	Enable     *bool     `json:"enable,omitempty"`
}

type DaemonCapacityProvider struct {
	ARN          *string `json:"arn,omitempty"`
	RunningCount *int64  `json:"runningCount,omitempty"`
}

type DaemonCircuitBreaker struct {
	FailureCount *int64 `json:"failureCount,omitempty"`
	Threshold    *int64 `json:"threshold,omitempty"`
}

type DaemonContainerDefinition struct {
	Command          []*string              `json:"command,omitempty"`
	CPU              *int64                 `json:"cpu,omitempty"`
	DependsOn        []*ContainerDependency `json:"dependsOn,omitempty"`
	EntryPoint       []*string              `json:"entryPoint,omitempty"`
	Environment      []*KeyValuePair        `json:"environment,omitempty"`
	EnvironmentFiles []*EnvironmentFile     `json:"environmentFiles,omitempty"`
	Essential        *bool                  `json:"essential,omitempty"`
	// The FireLens configuration for the container. This is used to specify and
	// configure a log router for container logs. For more information, see Custom
	// log routing (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
	// in the Amazon Elastic Container Service Developer Guide.
	FirelensConfiguration *FirelensConfiguration `json:"firelensConfiguration,omitempty"`
	// An object representing a container health check. Health check parameters
	// that are specified in a container definition override any Docker health checks
	// that exist in the container image (such as those specified in a parent image
	// or from the image's Dockerfile). This configuration maps to the HEALTHCHECK
	// parameter of docker run.
	//
	// The Amazon ECS container agent only monitors and reports on the health checks
	// specified in the task definition. Amazon ECS does not monitor Docker health
	// checks that are embedded in a container image and not specified in the container
	// definition. Health check parameters that are specified in a container definition
	// override any Docker health checks that exist in the container image.
	//
	// You can view the health status of both individual containers and a task with
	// the DescribeTasks API operation or when viewing the task details in the console.
	//
	// The health check is designed to make sure that your containers survive agent
	// restarts, upgrades, or temporary unavailability.
	//
	// Amazon ECS performs health checks on containers with the default that launched
	// the container instance or the task.
	//
	// The following describes the possible healthStatus values for a container:
	//
	//    * HEALTHY-The container health check has passed successfully.
	//
	//    * UNHEALTHY-The container health check has failed.
	//
	//    * UNKNOWN-The container health check is being evaluated, there's no container
	//    health check defined, or Amazon ECS doesn't have the health status of
	//    the container.
	//
	// The following describes the possible healthStatus values based on the container
	// health checker status of essential containers in the task with the following
	// priority order (high to low):
	//
	//    * UNHEALTHY-One or more essential containers have failed their health
	//    check.
	//
	//    * UNKNOWN-Any essential container running within the task is in an UNKNOWN
	//    state and no other essential containers have an UNHEALTHY state.
	//
	//    * HEALTHY-All essential containers within the task have passed their health
	//    checks.
	//
	// Consider the following task health example with 2 containers.
	//
	//    * If Container1 is UNHEALTHY and Container2 is UNKNOWN, the task health
	//    is UNHEALTHY.
	//
	//    * If Container1 is UNHEALTHY and Container2 is HEALTHY, the task health
	//    is UNHEALTHY.
	//
	//    * If Container1 is HEALTHY and Container2 is UNKNOWN, the task health
	//    is UNKNOWN.
	//
	//    * If Container1 is HEALTHY and Container2 is HEALTHY, the task health
	//    is HEALTHY.
	//
	// Consider the following task health example with 3 containers.
	//
	//    * If Container1 is UNHEALTHY and Container2 is UNKNOWN, and Container3
	//    is UNKNOWN, the task health is UNHEALTHY.
	//
	//    * If Container1 is UNHEALTHY and Container2 is UNKNOWN, and Container3
	//    is HEALTHY, the task health is UNHEALTHY.
	//
	//    * If Container1 is UNHEALTHY and Container2 is HEALTHY, and Container3
	//    is HEALTHY, the task health is UNHEALTHY.
	//
	//    * If Container1 is HEALTHY and Container2 is UNKNOWN, and Container3 is
	//    HEALTHY, the task health is UNKNOWN.
	//
	//    * If Container1 is HEALTHY and Container2 is UNKNOWN, and Container3 is
	//    UNKNOWN, the task health is UNKNOWN.
	//
	//    * If Container1 is HEALTHY and Container2 is HEALTHY, and Container3 is
	//    HEALTHY, the task health is HEALTHY.
	//
	// If a task is run manually, and not as part of a service, the task will continue
	// its lifecycle regardless of its health status. For tasks that are part of
	// a service, if the task reports as unhealthy then the task will be stopped
	// and the service scheduler will replace it.
	//
	// When a container health check fails for a task that is part of a service,
	// the following process occurs:
	//
	// The task is marked as UNHEALTHY.
	//
	// The unhealthy task will be stopped, and during the stopping process, it will
	// go through the following states:
	//
	//    * DEACTIVATING - In this state, Amazon ECS performs additional steps before
	//    stopping the task. For example, for tasks that are part of services configured
	//    to use Elastic Load Balancing target groups, target groups will be deregistered
	//    in this state.
	//
	//    * STOPPING - The task is in the process of being stopped.
	//
	//    * DEPROVISIONING - Resources associated with the task are being cleaned
	//    up.
	//
	//    * STOPPED - The task has been completely stopped.
	//
	// After the old task stops, a new task will be launched to ensure service operation,
	// and the new task will go through the following lifecycle:
	//
	//    * PROVISIONING - Resources required for the task are being provisioned.
	//
	//    * PENDING - The task is waiting to be placed on a container instance.
	//
	//    * ACTIVATING - In this state, Amazon ECS pulls container images, creates
	//    containers, configures task networking, registers load balancer target
	//    groups, and configures service discovery status.
	//
	//    * RUNNING - The task is running and performing its work.
	//
	// For more detailed information about task lifecycle states, see Task lifecycle
	// (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle-explanation.html)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// The following are notes about container health check support:
	//
	//    * If the Amazon ECS container agent becomes disconnected from the Amazon
	//    ECS service, this won't cause a container to transition to an UNHEALTHY
	//    status. This is by design, to ensure that containers remain running during
	//    agent restarts or temporary unavailability. The health check status is
	//    the "last heard from" response from the Amazon ECS agent, so if the container
	//    was considered HEALTHY prior to the disconnect, that status will remain
	//    until the agent reconnects and another health check occurs. There are
	//    no assumptions made about the status of the container health checks.
	//
	//    * Container health checks require version 1.17.0 or greater of the Amazon
	//    ECS container agent. For more information, see Updating the Amazon ECS
	//    container agent (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).
	//
	//    * Container health checks are supported for Fargate tasks if you're using
	//    platform version 1.1.0 or greater. For more information, see Fargate platform
	//    versions (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).
	//
	//    * Container health checks aren't supported for tasks that are part of
	//    a service that's configured to use a Classic Load Balancer.
	//
	// For an example of how to specify a task definition with multiple containers
	// where container dependency is specified, see Container dependency (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/example_task_definitions.html#example_task_definition-containerdependency)
	// in the Amazon Elastic Container Service Developer Guide.
	HealthCheck *HealthCheck `json:"healthCheck,omitempty"`
	Image       *string      `json:"image,omitempty"`
	Interactive *bool        `json:"interactive,omitempty"`
	// The log configuration for the container. This parameter maps to LogConfig
	// in the docker container create command and the --log-driver option to docker
	// run.
	//
	// By default, containers use the same logging driver that the Docker daemon
	// uses. However, the container might use a different logging driver than the
	// Docker daemon by specifying a log driver configuration in the container definition.
	//
	// Understand the following when specifying a log configuration for your containers.
	//
	//    * Amazon ECS currently supports a subset of the logging drivers available
	//    to the Docker daemon. Additional log drivers may be available in future
	//    releases of the Amazon ECS container agent. For tasks on Fargate, the
	//    supported log drivers are awslogs, splunk, and awsfirelens. For tasks
	//    hosted on Amazon EC2 instances, the supported log drivers are awslogs,
	//    fluentd, gelf, json-file, journald,syslog, splunk, and awsfirelens.
	//
	//    * This parameter requires version 1.18 of the Docker Remote API or greater
	//    on your container instance.
	//
	//    * For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container
	//    agent must register the available logging drivers with the ECS_AVAILABLE_LOGGING_DRIVERS
	//    environment variable before containers placed on that instance can use
	//    these log configuration options. For more information, see Amazon ECS
	//    container agent configuration (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html)
	//    in the Amazon Elastic Container Service Developer Guide.
	//
	//    * For tasks that are on Fargate, because you don't have access to the
	//    underlying infrastructure your tasks are hosted on, any additional software
	//    needed must be installed outside of the task. For example, the Fluentd
	//    output aggregators or a remote host running Logstash to send Gelf logs
	//    to.
	LogConfiguration       *LogConfiguration `json:"logConfiguration,omitempty"`
	Memory                 *int64            `json:"memory,omitempty"`
	MemoryReservation      *int64            `json:"memoryReservation,omitempty"`
	MountPoints            []*MountPoint     `json:"mountPoints,omitempty"`
	Name                   *string           `json:"name,omitempty"`
	Privileged             *bool             `json:"privileged,omitempty"`
	PseudoTerminal         *bool             `json:"pseudoTerminal,omitempty"`
	ReadonlyRootFilesystem *bool             `json:"readonlyRootFilesystem,omitempty"`
	// The repository credentials for private registry authentication.
	RepositoryCredentials *RepositoryCredentials `json:"repositoryCredentials,omitempty"`
	Secrets               []*Secret              `json:"secrets,omitempty"`
	StartTimeout          *int64                 `json:"startTimeout,omitempty"`
	StopTimeout           *int64                 `json:"stopTimeout,omitempty"`
	SystemControls        []*SystemControl       `json:"systemControls,omitempty"`
	Ulimits               []*Ulimit              `json:"ulimits,omitempty"`
	User                  *string                `json:"user,omitempty"`
	WorkingDirectory      *string                `json:"workingDirectory,omitempty"`
}

type DaemonContainerImage struct {
	ContainerName *string `json:"containerName,omitempty"`
	Image         *string `json:"image,omitempty"`
	ImageDigest   *string `json:"imageDigest,omitempty"`
}

type DaemonDeployment struct {
	ClusterARN          *string      `json:"clusterARN,omitempty"`
	CreatedAt           *metav1.Time `json:"createdAt,omitempty"`
	DaemonDeploymentARN *string      `json:"daemonDeploymentARN,omitempty"`
	FinishedAt          *metav1.Time `json:"finishedAt,omitempty"`
	StartedAt           *metav1.Time `json:"startedAt,omitempty"`
	StatusReason        *string      `json:"statusReason,omitempty"`
	StoppedAt           *metav1.Time `json:"stoppedAt,omitempty"`
}

type DaemonDeploymentAlarms struct {
	AlarmNames          []*string `json:"alarmNames,omitempty"`
	TriggeredAlarmNames []*string `json:"triggeredAlarmNames,omitempty"`
}

type DaemonDeploymentCapacityProvider struct {
	ARN                   *string `json:"arn,omitempty"`
	DrainingInstanceCount *int64  `json:"drainingInstanceCount,omitempty"`
	RunningInstanceCount  *int64  `json:"runningInstanceCount,omitempty"`
}

type DaemonDeploymentConfiguration struct {
	BakeTimeInMinutes *int64 `json:"bakeTimeInMinutes,omitempty"`
}

type DaemonDeploymentRevisionDetail struct {
	ARN                        *string `json:"arn,omitempty"`
	TotalDrainingInstanceCount *int64  `json:"totalDrainingInstanceCount,omitempty"`
	TotalRunningInstanceCount  *int64  `json:"totalRunningInstanceCount,omitempty"`
}

type DaemonDeploymentRollbackMonitorsStatus string

type DaemonDeploymentStatus string

type DaemonDeploymentSummary struct {
	ClusterARN              *string      `json:"clusterARN,omitempty"`
	CreatedAt               *metav1.Time `json:"createdAt,omitempty"`
	DaemonARN               *string      `json:"daemonARN,omitempty"`
	DaemonDeploymentARN     *string      `json:"daemonDeploymentARN,omitempty"`
	FinishedAt              *metav1.Time `json:"finishedAt,omitempty"`
	StartedAt               *metav1.Time `json:"startedAt,omitempty"`
	StatusReason            *string      `json:"statusReason,omitempty"`
	StoppedAt               *metav1.Time `json:"stoppedAt,omitempty"`
	TargetDaemonRevisionARN *string      `json:"targetDaemonRevisionARN,omitempty"`
}

type DaemonDetail struct {
	ClusterARN    *string      `json:"clusterARN,omitempty"`
	CreatedAt     *metav1.Time `json:"createdAt,omitempty"`
	DaemonARN     *string      `json:"daemonARN,omitempty"`
	DeploymentARN *string      `json:"deploymentARN,omitempty"`
	UpdatedAt     *metav1.Time `json:"updatedAt,omitempty"`
}

type DaemonLinuxParameters struct {
	// The Linux capabilities to add or remove from the default Docker configuration
	// for a container defined in the task definition. For more detailed information
	// about these Linux capabilities, see the capabilities(7) (http://man7.org/linux/man-pages/man7/capabilities.7.html)
	// Linux manual page.
	//
	// The following describes how Docker processes the Linux capabilities specified
	// in the add and drop request parameters. For information about the latest
	// behavior, see Docker Compose: order of cap_drop and cap_add (https://forums.docker.com/t/docker-compose-order-of-cap-drop-and-cap-add/97136/1)
	// in the Docker Community Forum.
	//
	//    * When the container is a privleged container, the container capabilities
	//    are all of the default Docker capabilities. The capabilities specified
	//    in the add request parameter, and the drop request parameter are ignored.
	//
	//    * When the add request parameter is set to ALL, the container capabilities
	//    are all of the default Docker capabilities, excluding those specified
	//    in the drop request parameter.
	//
	//    * When the drop request parameter is set to ALL, the container capabilities
	//    are the capabilities specified in the add request parameter.
	//
	//    * When the add request parameter and the drop request parameter are both
	//    empty, the capabilities the container capabilities are all of the default
	//    Docker capabilities.
	//
	//    * The default is to first drop the capabilities specified in the drop
	//    request parameter, and then add the capabilities specified in the add
	//    request parameter.
	Capabilities       *KernelCapabilities `json:"capabilities,omitempty"`
	Devices            []*Device           `json:"devices,omitempty"`
	InitProcessEnabled *bool               `json:"initProcessEnabled,omitempty"`
	Tmpfs              []*Tmpfs            `json:"tmpfs,omitempty"`
}

type DaemonPropagateTags string

type DaemonRevision struct {
	ClusterARN              *string      `json:"clusterARN,omitempty"`
	CreatedAt               *metav1.Time `json:"createdAt,omitempty"`
	DaemonARN               *string      `json:"daemonARN,omitempty"`
	DaemonRevisionARN       *string      `json:"daemonRevisionARN,omitempty"`
	DaemonTaskDefinitionARN *string      `json:"daemonTaskDefinitionARN,omitempty"`
	EnableECSManagedTags    *bool        `json:"enableECSManagedTags,omitempty"`
	EnableExecuteCommand    *bool        `json:"enableExecuteCommand,omitempty"`
}

type DaemonRevisionDetail struct {
	ARN               *string `json:"arn,omitempty"`
	TotalRunningCount *int64  `json:"totalRunningCount,omitempty"`
}

type DaemonRollback struct {
	Reason                          *string      `json:"reason,omitempty"`
	RollbackCapacityProviders       []*string    `json:"rollbackCapacityProviders,omitempty"`
	RollbackTargetDaemonRevisionARN *string      `json:"rollbackTargetDaemonRevisionARN,omitempty"`
	StartedAt                       *metav1.Time `json:"startedAt,omitempty"`
}

type DaemonStatus string

type DaemonSummary struct {
	CreatedAt *metav1.Time `json:"createdAt,omitempty"`
	DaemonARN *string      `json:"daemonARN,omitempty"`
	UpdatedAt *metav1.Time `json:"updatedAt,omitempty"`
}

type DaemonTaskDefinition struct {
	CPU                     *string      `json:"cpu,omitempty"`
	DaemonTaskDefinitionARN *string      `json:"daemonTaskDefinitionARN,omitempty"`
	DeleteRequestedAt       *metav1.Time `json:"deleteRequestedAt,omitempty"`
	ExecutionRoleARN        *string      `json:"executionRoleARN,omitempty"`
	Family                  *string      `json:"family,omitempty"`
	Memory                  *string      `json:"memory,omitempty"`
	RegisteredAt            *metav1.Time `json:"registeredAt,omitempty"`
	RegisteredBy            *string      `json:"registeredBy,omitempty"`
	Revision                *int64       `json:"revision,omitempty"`
	TaskRoleARN             *string      `json:"taskRoleARN,omitempty"`
}

type DaemonTaskDefinitionRevisionFilter string

type DaemonTaskDefinitionStatus string

type DaemonTaskDefinitionStatusFilter string

type DaemonTaskDefinitionSummary struct {
	ARN               *string      `json:"arn,omitempty"`
	DeleteRequestedAt *metav1.Time `json:"deleteRequestedAt,omitempty"`
	RegisteredAt      *metav1.Time `json:"registeredAt,omitempty"`
	RegisteredBy      *string      `json:"registeredBy,omitempty"`
}

type DaemonVolume struct {
	// Details on a container instance bind mount host volume.
	Host *HostVolumeProperties `json:"host,omitempty"`
	Name *string               `json:"name,omitempty"`
}

type Deployment struct {
	CapacityProviderStrategy []*CapacityProviderStrategyItem `json:"capacityProviderStrategy,omitempty"`
	CreatedAt                *metav1.Time                    `json:"createdAt,omitempty"`
	DesiredCount             *int64                          `json:"desiredCount,omitempty"`
	FailedTasks              *int64                          `json:"failedTasks,omitempty"`
	ID                       *string                         `json:"id,omitempty"`
	LaunchType               *string                         `json:"launchType,omitempty"`
	// The network configuration for a task or service.
	NetworkConfiguration *NetworkConfiguration `json:"networkConfiguration,omitempty"`
	PendingCount         *int64                `json:"pendingCount,omitempty"`
	PlatformFamily       *string               `json:"platformFamily,omitempty"`
	PlatformVersion      *string               `json:"platformVersion,omitempty"`
	RolloutState         *string               `json:"rolloutState,omitempty"`
	RolloutStateReason   *string               `json:"rolloutStateReason,omitempty"`
	RunningCount         *int64                `json:"runningCount,omitempty"`
	// The Service Connect configuration of your Amazon ECS service. The configuration
	// for this service to discover and connect to services, and be discovered by,
	// and connected from, other services within a namespace.
	//
	// Tasks that run in a namespace can use short names to connect to services
	// in the namespace. Tasks can connect to services across all of the clusters
	// in the namespace. Tasks connect through a managed proxy container that collects
	// logs and metrics for increased visibility. Only the tasks that Amazon ECS
	// services create are supported with Service Connect. For more information,
	// see Service Connect (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html)
	// in the Amazon Elastic Container Service Developer Guide.
	ServiceConnectConfiguration *ServiceConnectConfiguration     `json:"serviceConnectConfiguration,omitempty"`
	ServiceConnectResources     []*ServiceConnectServiceResource `json:"serviceConnectResources,omitempty"`
	Status                      *string                          `json:"status,omitempty"`
	TaskDefinition              *string                          `json:"taskDefinition,omitempty"`
	UpdatedAt                   *metav1.Time                     `json:"updatedAt,omitempty"`
	VolumeConfigurations        []*ServiceVolumeConfiguration    `json:"volumeConfigurations,omitempty"`
}

type DeploymentAlarms struct {
	AlarmNames []*string `json:"alarmNames,omitempty"`
	Enable     *bool     `json:"enable,omitempty"`
	Rollback   *bool     `json:"rollback,omitempty"`
}

type DeploymentCircuitBreaker struct {
	Enable   *bool `json:"enable,omitempty"`
	Rollback *bool `json:"rollback,omitempty"`
}

type DeploymentConfiguration struct {
	// One of the methods which provide a way for you to quickly identify when a
	// deployment has failed, and then to optionally roll back the failure to the
	// last working deployment.
	//
	// When the alarms are generated, Amazon ECS sets the service deployment to
	// failed. Set the rollback parameter to have Amazon ECS to roll back your service
	// to the last completed deployment after a failure.
	//
	// You can only use the DeploymentAlarms method to detect failures when the
	// DeploymentController is set to ECS.
	//
	// For more information, see Rolling update (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html)
	// in the Amazon Elastic Container Service Developer Guide .
	Alarms *DeploymentAlarms `json:"alarms,omitempty"`
	//
	// The deployment circuit breaker can only be used for services using the rolling
	// update (ECS) deployment type.
	//
	// The deployment circuit breaker determines whether a service deployment will
	// fail if the service can't reach a steady state. If it is turned on, a service
	// deployment will transition to a failed state and stop launching new tasks.
	// You can also configure Amazon ECS to roll back your service to the last completed
	// deployment after a failure. For more information, see Rolling update (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html)
	// in the Amazon Elastic Container Service Developer Guide.
	//
	// For more information about API failure reasons, see API failure reasons (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html)
	// in the Amazon Elastic Container Service Developer Guide.
	DeploymentCircuitBreaker *DeploymentCircuitBreaker `json:"deploymentCircuitBreaker,omitempty"`
	MaximumPercent           *int64                    `json:"maximumPercent,omitempty"`
	MinimumHealthyPercent    *int64                    `json:"minimumHealthyPercent,omitempty"`
}

type DeploymentController struct {
	Type *string `json:"type,omitempty"`
}

type DeploymentControllerType string

type DeploymentEphemeralStorage struct {
	KMSKeyID *string `json:"kmsKeyID,omitempty"`
}

type DeploymentLifecycleHook struct {
	HookTargetARN *string `json:"hookTargetARN,omitempty"`
	RoleARN       *string `json:"roleARN,omitempty"`
}

type DeploymentLifecycleHookAction string

type DeploymentLifecycleHookDetail struct {
	ExpiresAt *metav1.Time `json:"expiresAt,omitempty"`
	HookID    *string      `json:"hookID,omitempty"`
	TargetARN *string      `json:"targetARN,omitempty"`
}

type DeploymentLifecycleHookStage string

type DeploymentLifecycleHookStatus string

type DeploymentLifecycleHookTargetType string

type DeploymentRolloutState string

type DeploymentStrategy string

type DesiredStatus string

type Device struct {
	ContainerPath *string   `json:"containerPath,omitempty"`
	HostPath      *string   `json:"hostPath,omitempty"`
	Permissions   []*string `json:"permissions,omitempty"`
}

type DeviceCgroupPermission string

type DockerVolumeConfiguration struct {
	Autoprovision *bool              `json:"autoprovision,omitempty"`
	Driver        *string            `json:"driver,omitempty"`
	DriverOpts    map[string]*string `json:"driverOpts,omitempty"`
	Labels        map[string]*string `json:"labels,omitempty"`
	Scope         *string            `json:"scope,omitempty"`
}

type EBSResourceType string

type EBSTagSpecification struct {
	PropagateTags *string `json:"propagateTags,omitempty"`
	ResourceType  *string `json:"resourceType,omitempty"`
	Tags          []*Tag  `json:"tags,omitempty"`
}

type ECSExpressGatewayService struct {
	Cluster               *string      `json:"cluster,omitempty"`
	CreatedAt             *metav1.Time `json:"createdAt,omitempty"`
	CurrentDeployment     *string      `json:"currentDeployment,omitempty"`
	InfrastructureRoleARN *string      `json:"infrastructureRoleARN,omitempty"`
	ServiceARN            *string      `json:"serviceARN,omitempty"`
	ServiceName           *string      `json:"serviceName,omitempty"`
	Tags                  []*Tag       `json:"tags,omitempty"`
	UpdatedAt             *metav1.Time `json:"updatedAt,omitempty"`
}

type EFSAuthorizationConfig struct {
	AccessPointID *string `json:"accessPointID,omitempty"`
	IAM           *string `json:"iam,omitempty"`
}

type EFSAuthorizationConfigIAM string

type EFSTransitEncryption string

type EFSVolumeConfiguration struct {
	// The authorization configuration details for the Amazon EFS file system.
	AuthorizationConfig   *EFSAuthorizationConfig `json:"authorizationConfig,omitempty"`
	FileSystemID          *string                 `json:"fileSystemID,omitempty"`
	RootDirectory         *string                 `json:"rootDirectory,omitempty"`
	TransitEncryption     *string                 `json:"transitEncryption,omitempty"`
	TransitEncryptionPort *int64                  `json:"transitEncryptionPort,omitempty"`
}

type EnvironmentFile struct {
	Type  *string `json:"type,omitempty"`
	Value *string `json:"value,omitempty"`
}

type EnvironmentFileType string

type EphemeralStorage struct {
	SizeInGiB *int64 `json:"sizeInGiB,omitempty"`
}

type ExecuteCommandConfiguration struct {
	KMSKeyID *string `json:"kmsKeyID,omitempty"`
	// The log configuration for the results of the execute command actions. The
	// logs can be sent to CloudWatch Logs or an Amazon S3 bucket.
	LogConfiguration *ExecuteCommandLogConfiguration `json:"logConfiguration,omitempty"`
	Logging          *string                         `json:"logging,omitempty"`
}

type ExecuteCommandLogConfiguration struct {
	CloudWatchEncryptionEnabled *bool   `json:"cloudWatchEncryptionEnabled,omitempty"`
	CloudWatchLogGroupName      *string `json:"cloudWatchLogGroupName,omitempty"`
	S3BucketName                *string `json:"s3BucketName,omitempty"`
	S3EncryptionEnabled         *bool   `json:"s3EncryptionEnabled,omitempty"`
	S3KeyPrefix                 *string `json:"s3KeyPrefix,omitempty"`
}

type ExecuteCommandLogging string

type ExpressGatewayContainer struct {
	Command       []*string       `json:"command,omitempty"`
	ContainerPort *int64          `json:"containerPort,omitempty"`
	Environment   []*KeyValuePair `json:"environment,omitempty"`
	Image         *string         `json:"image,omitempty"`
	Secrets       []*Secret       `json:"secrets,omitempty"`
}

type ExpressGatewayRepositoryCredentials struct {
	CredentialsParameter *string `json:"credentialsParameter,omitempty"`
}

type ExpressGatewayScalingTarget struct {
	AutoScalingTargetValue *int64 `json:"autoScalingTargetValue,omitempty"`
	MaxTaskCount           *int64 `json:"maxTaskCount,omitempty"`
	MinTaskCount           *int64 `json:"minTaskCount,omitempty"`
}

type ExpressGatewayServiceAWSLogsConfiguration struct {
	LogGroup        *string `json:"logGroup,omitempty"`
	LogStreamPrefix *string `json:"logStreamPrefix,omitempty"`
}

type ExpressGatewayServiceConfiguration struct {
	CPU                *string      `json:"cpu,omitempty"`
	CreatedAt          *metav1.Time `json:"createdAt,omitempty"`
	ExecutionRoleARN   *string      `json:"executionRoleARN,omitempty"`
	HealthCheckPath    *string      `json:"healthCheckPath,omitempty"`
	Memory             *string      `json:"memory,omitempty"`
	ServiceRevisionARN *string      `json:"serviceRevisionARN,omitempty"`
	TaskRoleARN        *string      `json:"taskRoleARN,omitempty"`
}

type ExpressGatewayServiceInclude string

type ExpressGatewayServiceNetworkConfiguration struct {
	SecurityGroups []*string `json:"securityGroups,omitempty"`
	Subnets        []*string `json:"subnets,omitempty"`
}

type ExpressGatewayServiceScalingMetric string

type ExpressGatewayServiceStatus struct {
	StatusReason *string `json:"statusReason,omitempty"`
}

type ExpressGatewayServiceStatusCode string

type FSxWindowsFileServerAuthorizationConfig struct {
	CredentialsParameter *string `json:"credentialsParameter,omitempty"`
	Domain               *string `json:"domain,omitempty"`
}

type FSxWindowsFileServerVolumeConfiguration struct {
	// The authorization configuration details for Amazon FSx for Windows File Server
	// file system. See FSxWindowsFileServerVolumeConfiguration (https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_FSxWindowsFileServerVolumeConfiguration.html)
	// in the Amazon ECS API Reference.
	//
	// For more information and the input format, see Amazon FSx for Windows File
	// Server Volumes (https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html)
	// in the Amazon Elastic Container Service Developer Guide.
	AuthorizationConfig *FSxWindowsFileServerAuthorizationConfig `json:"authorizationConfig,omitempty"`
	FileSystemID        *string                                  `json:"fileSystemID,omitempty"`
	RootDirectory       *string                                  `json:"rootDirectory,omitempty"`
}

type Failure struct {
	ARN    *string `json:"arn,omitempty"`
	Detail *string `json:"detail,omitempty"`
	Reason *string `json:"reason,omitempty"`
}

type FirelensConfiguration struct {
	Options map[string]*string `json:"options,omitempty"`
	Type    *string            `json:"type,omitempty"`
}

type FirelensConfigurationType string

type HealthCheck struct {
	Command     []*string `json:"command,omitempty"`
	Interval    *int64    `json:"interval,omitempty"`
	Retries     *int64    `json:"retries,omitempty"`
	StartPeriod *int64    `json:"startPeriod,omitempty"`
	Timeout     *int64    `json:"timeout,omitempty"`
}

type HealthStatus string

type HostEntry struct {
	Hostname  *string `json:"hostname,omitempty"`
	IPAddress *string `json:"ipAddress,omitempty"`
}

type HostVolumeProperties struct {
	SourcePath *string `json:"sourcePath,omitempty"`
}

type IPCMode string

type InferenceAccelerator struct {
	DeviceName *string `json:"deviceName,omitempty"`
	DeviceType *string `json:"deviceType,omitempty"`
}

type InferenceAcceleratorOverride struct {
	DeviceName *string `json:"deviceName,omitempty"`
	DeviceType *string `json:"deviceType,omitempty"`
}

type InfrastructureOptimization struct {
	ScaleInAfter *int64 `json:"scaleInAfter,omitempty"`
}

type IngressPathSummary struct {
	Endpoint *string `json:"endpoint,omitempty"`
}