v1beta1

type AccessConfig struct {
	// The desired authentication mode for the cluster.
	// +kubebuilder:validation:Enum=API;API_AND_CONFIG_MAP;CONFIG_MAP
	// +optional
	AuthenticationMode *AuthenticationMode `json:"authenticationMode,omitempty"`
}

type AccessConfigResponse struct {
	// The authentication mode used for the cluster.
	AuthenticationMode AuthenticationMode `json:"authenticationMode,omitempty"`
}

type AuthenticationMode string

type Cluster struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   ClusterSpec   `json:"spec"`
	Status ClusterStatus `json:"status,omitempty"`
}

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

type ClusterObservation struct {
	// The Amazon Resource Name (ARN) of the cluster.
	Arn string `json:"arn,omitempty"`

	// The Unix epoch timestamp in seconds for when the cluster was created.
	CreatedAt *metav1.Time `json:"createdAt,omitempty"`

	// The endpoint for your Kubernetes API server.
	Endpoint string `json:"endpoint,omitempty"`

	// The Base64-encoded certificate data required to communicate with your cluster.
	CertificateAuthorityData string `json:"certificateAuthorityData,omitempty"`

	// The identity provider information for the cluster.
	Identity Identity `json:"identity,omitempty"`

	// The kubernetes version of your Amazon EKS cluster. For more information, see
	// Kubernetes Versions (https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions.html)
	// in the Amazon EKS User Guide .
	Version string `json:"version,omitempty"`

	// The platform version of your Amazon EKS cluster. For more information, see
	// Platform Versions (https://docs.aws.amazon.com/eks/latest/userguide/platform-versions.html)
	// in the Amazon EKS User Guide .
	PlatformVersion string `json:"platformVersion,omitempty"`

	// An object representing the configuration of your local Amazon EKS cluster on an
	// Amazon Web Services Outpost. This object isn't available for clusters on the
	// Amazon Web Services cloud.
	OutpostConfig OutpostConfigResponse `json:"outpostConfig,omitempty"`

	// The Kubernetes network configuration for the cluster.
	KubernetesNetworkConfig KubernetesNetworkConfigResponse `json:"kubernetesNetworkConfig,omitempty"`

	// The VPC configuration used by the cluster control plane. Amazon EKS VPC resources
	// have specific requirements to work properly with Kubernetes. For more information,
	// see Cluster VPC Considerations (https://docs.aws.amazon.com/eks/latest/userguide/network_reqs.html)
	// and Cluster Security Group Considerations (https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html)
	// in the Amazon EKS User Guide.
	ResourcesVpcConfig VpcConfigResponse `json:"resourcesVpcConfig,omitempty"`

	// The access configuration for the cluster.
	AccessConfig AccessConfigResponse `json:"accessConfig,omitempty"`

	// The current status of the cluster.
	Status ClusterStatusType `json:"status,omitempty"`
}

type ClusterParameters struct {
	// The access configuration for the cluster.
	// +optional
	AccessConfig *AccessConfig `json:"accessConfig,omitempty"`

	// Region is the region you'd like your Cluster to be created in.
	// +optional
	Region *string `json:"region,omitempty"`

	// The encryption configuration for the cluster.
	// +immutable
	// +optional
	EncryptionConfig []EncryptionConfig `json:"encryptionConfig,omitempty"`

	// The Kubernetes network configuration for the cluster.
	// +immutable
	// +optional
	KubernetesNetworkConfig *KubernetesNetworkConfigRequest `json:"kubernetesNetworkConfig,omitempty"`

	// Enable or disable exporting the Kubernetes control plane logs for your cluster
	// to CloudWatch Logs. By default, cluster control plane logs aren't exported
	// to CloudWatch Logs. For more information, see Amazon EKS Cluster Control
	// Plane Logs (https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html)
	// in the Amazon EKS User Guide .
	//
	// CloudWatch Logs ingestion, archive storage, and data scanning rates apply
	// to exported control plane logs. For more information, see Amazon CloudWatch
	// Pricing (http://aws.amazon.com/cloudwatch/pricing/).
	// +optional
	Logging *Logging `json:"logging,omitempty"`

	// An object representing the configuration of your local Amazon EKS cluster on an
	// Amazon Web Services Outpost. Before creating a local cluster on an Outpost,
	// review Creating an Amazon EKS cluster on an Amazon Web Services Outpost
	// (https://docs.aws.amazon.com/eks/latest/userguide/create-cluster-outpost.html)
	// in the Amazon EKS User Guide. This object isn't available for creating Amazon
	// EKS clusters on the Amazon Web Services cloud.
	// +optional
	OutpostConfig *OutpostConfigRequest `json:"outpostConfig,omitempty"`

	// The VPC configuration used by the cluster control plane. Amazon EKS VPC resources
	// have specific requirements to work properly with Kubernetes. For more information,
	// see Cluster VPC Considerations (https://docs.aws.amazon.com/eks/latest/userguide/network_reqs.html)
	// and Cluster Security Group Considerations (https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html)
	// in the Amazon EKS User Guide. You must specify at least two subnets. You
	// can specify up to five security groups, but we recommend that you use a dedicated
	// security group for your cluster control plane.
	//
	// ResourcesVpcConfig is a required field
	ResourcesVpcConfig VpcConfigRequest `json:"resourcesVpcConfig"`

	// The Amazon Resource Name (ARN) of the IAM role that provides permissions
	// for Amazon EKS to make calls to other AWS API operations on your behalf.
	// For more information, see Amazon EKS Service IAM Role (https://docs.aws.amazon.com/eks/latest/userguide/service_IAM_role.html)
	// in the Amazon EKS User Guide .
	//
	// RoleArn is a required field
	// +immutable
	// +crossplane:generate:reference:type=github.com/crossplane-contrib/provider-aws/apis/iam/v1beta1.Role
	// +crossplane:generate:reference:extractor=github.com/crossplane-contrib/provider-aws/apis/iam/v1beta1.RoleARN()
	RoleArn string `json:"roleArn,omitempty"`

	// RoleArnRef is a reference to an IAMRole used to set
	// the RoleArn.
	// +immutable
	// +optional
	RoleArnRef *xpv1.Reference `json:"roleArnRef,omitempty"`

	// RoleArnSelector selects references to IAMRole used
	// to set the RoleArn.
	// +optional
	RoleArnSelector *xpv1.Selector `json:"roleArnSelector,omitempty"`

	// The metadata to apply to the cluster to assist with categorization and organization.
	// Each tag consists of a key and an optional value, both of which you define.
	// +optional
	Tags map[string]string `json:"tags,omitempty"`

	// The desired Kubernetes version for your cluster. If you don't specify a value
	// here, the latest version available in Amazon EKS is used.
	// Example: 1.15
	// +optional
	Version *string `json:"version,omitempty"`
}

type ClusterSpec struct {
	xpv1.ResourceSpec `json:",inline"`
	ForProvider       ClusterParameters `json:"forProvider"`
}

type ClusterStatus struct {
	xpv1.ResourceStatus `json:",inline"`
	AtProvider          ClusterObservation `json:"atProvider,omitempty"`
}

type ClusterStatusType string

type EncryptionConfig struct {

	// AWS Key Management Service (AWS KMS) customer master key (CMK). Either the
	// ARN or the alias can be used.
	Provider Provider `json:"provider"`

	// Specifies the resources to be encrypted. The only supported value is "secrets".
	Resources []string `json:"resources"`
}

type FargateProfile struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   FargateProfileSpec   `json:"spec"`
	Status FargateProfileStatus `json:"status,omitempty"`
}

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

type FargateProfileObservation struct {
	// The Unix epoch timestamp in seconds for when the Fargate profile was created.
	CreatedAt *metav1.Time `json:"createdAt,omitempty"`

	// The full Amazon Resource Name (ARN) of the Fargate profile.
	FargateProfileArn string `json:"fargateProfileArn,omitempty"`

	// The current status of the Fargate profile.
	Status FargateProfileStatusType `json:"status,omitempty"`
}

type FargateProfileParameters struct {

	// Region is the region you'd like  the FargateProfile to be created in.
	// +immutable
	Region string `json:"region"`

	// The name of the Amazon EKS cluster to apply the Fargate profile to.
	//
	// ClusterName is a required field
	// +immutable
	// +crossplane:generate:reference:type=Cluster
	ClusterName string `json:"clusterName,omitempty"`

	// ClusterNameRef is a reference to a Cluster used to set
	// the ClusterName.
	// +immutable
	// +optional
	ClusterNameRef *xpv1.Reference `json:"clusterNameRef,omitempty"`

	// ClusterNameSelector selects references to a Cluster used
	// to set the ClusterName.
	// +optional
	ClusterNameSelector *xpv1.Selector `json:"clusterNameSelector,omitempty"`

	// The Amazon Resource Name (ARN) of the pod execution role to use for pods
	// that match the selectors in the Fargate profile. The pod execution role allows
	// Fargate infrastructure to register with your cluster as a node, and it provides
	// read access to Amazon ECR image repositories. For more information, see Pod
	// Execution Role (https://docs.aws.amazon.com/eks/latest/userguide/pod-execution-role.html)
	// in the Amazon EKS User Guide.
	//
	// At least one of podExecutionRoleArn, podExecutionRoleArnRef or podExecutionRoleArnSelector has to be given
	// +immutable
	// +optional
	// +crossplane:generate:reference:type=github.com/crossplane-contrib/provider-aws/apis/iam/v1beta1.Role
	// +crossplane:generate:reference:extractor=github.com/crossplane-contrib/provider-aws/apis/iam/v1beta1.RoleARN()
	PodExecutionRoleArn string `json:"podExecutionRoleArn,omitempty"`

	// PodExecutionRoleArnRef is a reference to an IAMRole used to set
	// the PodExecutionRoleArn.
	// At least one of podExecutionRoleArn, podExecutionRoleArnRef or podExecutionRoleArnSelector has to be given
	// +immutable
	// +optional
	PodExecutionRoleArnRef *xpv1.Reference `json:"podExecutionRoleArnRef,omitempty"`

	// PodExecutionRoleArnSelector selects references to IAMRole used
	// to set the PodExecutionRoleArn.
	// At least one of podExecutionRoleArn, podExecutionRoleArnRef or podExecutionRoleArnSelector has to be given
	// +optional
	PodExecutionRoleArnSelector *xpv1.Selector `json:"podExecutionRoleArnSelector,omitempty"`

	// The selectors to match for pods to use this Fargate profile. Each selector
	// must have an associated namespace. Optionally, you can also specify labels
	// for a namespace. You may specify up to five selectors in a Fargate profile.
	// +immutable
	Selectors []FargateProfileSelector `json:"selectors,omitempty"`

	// The IDs of subnets to launch your pods into. At this time, pods running on
	// Fargate are not assigned public IP addresses, so only private subnets (with
	// no direct route to an Internet Gateway) are accepted for this parameter.
	// +optional
	// +immutable
	// +crossplane:generate:reference:type=github.com/crossplane-contrib/provider-aws/apis/ec2/v1beta1.Subnet
	// +crossplane:generate:reference:refFieldName=SubnetRefs
	// +crossplane:generate:reference:selectorFieldName=SubnetSelector
	Subnets []string `json:"subnets,omitempty"`

	// SubnetRefs are references to Subnets used to set the Subnets.
	// +immutable
	// +optional
	SubnetRefs []xpv1.Reference `json:"subnetRefs,omitempty"`

	// SubnetSelector selects references to Subnets used to set the Subnets.
	// +optional
	SubnetSelector *xpv1.Selector `json:"subnetSelector,omitempty"`

	// The metadata to apply to the Fargate profile to assist with categorization
	// and organization. Each tag consists of a key and an optional value, both
	// of which you define. Fargate profile tags do not propagate to any other resources
	// associated with the Fargate profile, such as the pods that are scheduled
	// with it.
	// +optional
	Tags map[string]string `json:"tags,omitempty"`
}

type FargateProfileSelector struct {

	// The Kubernetes labels that the selector should match. A pod must contain
	// all of the labels that are specified in the selector for it to be considered
	// a match.
	Labels map[string]string `json:"labels,omitempty"`

	// The Kubernetes namespace that the selector should match.
	Namespace *string `json:"namespace,omitempty"`
}

type FargateProfileSpec struct {
	xpv1.ResourceSpec `json:",inline"`
	ForProvider       FargateProfileParameters `json:"forProvider"`
}

type FargateProfileStatus struct {
	xpv1.ResourceStatus `json:",inline"`
	AtProvider          FargateProfileObservation `json:"atProvider,omitempty"`
}

type FargateProfileStatusType string

type IPFamily string

type Identity struct {

	// The OpenID Connect (https://openid.net/connect/) identity provider information
	// for the cluster.
	OIDC OIDC `json:"oidc,omitempty"`
}

type KubernetesNetworkConfigRequest struct {
	// Specify which IP family is used to assign Kubernetes pod and service IP
	// addresses. If you don't specify a value, ipv4 is used by default. You can only
	// specify an IP family when you create a cluster and can't change this value once
	// the cluster is created. If you specify ipv6, the VPC and subnets that you
	// specify for cluster creation must have both IPv4 and IPv6 CIDR blocks assigned
	// to them. You can't specify ipv6 for clusters in China Regions. You can only
	// specify ipv6 for 1.21 and later clusters that use version 1.10.1 or later of the
	// Amazon VPC CNI add-on. If you specify ipv6, then ensure that your VPC meets the
	// requirements listed in the considerations listed in Assigning IPv6 addresses to
	// pods and services
	// (https://docs.aws.amazon.com/eks/latest/userguide/cni-ipv6.html) in the Amazon
	// EKS User Guide. Kubernetes assigns services IPv6 addresses from the unique local
	// address range (fc00::/7). You can't specify a custom IPv6 CIDR block. Pod
	// addresses are assigned from the subnet's IPv6 CIDR.
	IPFamily IPFamily `json:"ipFamily"`

	// Don't specify a value if you select ipv6 for ipFamily. The CIDR block to assign
	// Kubernetes service IP addresses from. If you don't specify a block, Kubernetes
	// assigns addresses from either the 10.100.0.0/16 or 172.20.0.0/16 CIDR blocks. We
	// recommend that you specify a block that does not overlap with resources in other
	// networks that are peered or connected to your VPC. The block must meet the
	// following requirements:
	//
	// * Within one of the following private IP address
	// blocks: 10.0.0.0/8, 172.16.0.0/12, or 192.168.0.0/16.
	//
	// * Doesn't overlap with
	// any CIDR block assigned to the VPC that you selected for VPC.
	//
	// * Between /24 and
	// /12.
	//
	// You can only specify a custom CIDR block when you create a cluster and
	// can't change this value once the cluster is created.
	ServiceIpv4Cidr string `json:"serviceIpv4Cidr,omitempty"`
}

type KubernetesNetworkConfigResponse struct {
	// The IP family used to assign Kubernetes pod and service IP addresses. The IP
	// family is always ipv4, unless you have a 1.21 or later cluster running version
	// 1.10.1 or later of the Amazon VPC CNI add-on and specified ipv6 when you created
	// the cluster.
	IPFamily IPFamily `json:"ipFamily,omitempty"`

	// The CIDR block that Kubernetes pod and service IP addresses are assigned from.
	// Kubernetes assigns addresses from an IPv4 CIDR block assigned to a subnet that
	// the node is in. If you didn't specify a CIDR block when you created the cluster,
	// then Kubernetes assigns addresses from either the 10.100.0.0/16 or 172.20.0.0/16
	// CIDR blocks. If this was specified, then it was specified when the cluster was
	// created and it can't be changed.
	ServiceIpv4Cidr string `json:"serviceIpv4Cidr,omitempty"`

	// The CIDR block that Kubernetes pod and service IP addresses are assigned from if
	// you created a 1.21 or later cluster with version 1.10.1 or later of the Amazon
	// VPC CNI add-on and specified ipv6 for ipFamily when you created the cluster.
	// Kubernetes assigns service addresses from the unique local address range
	// (fc00::/7) because you can't specify a custom IPv6 CIDR block when you create
	// the cluster.
	ServiceIpv6Cidr string `json:"serviceIpv6Cidr,omitempty"`
}

type LogSetup struct {
	// If a log type is enabled, that log type exports its control plane logs to
	// CloudWatch Logs. If a log type isn't enabled, that log type doesn't export
	// its control plane logs. Each individual log type can be enabled or disabled
	// independently.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`

	// The available cluster control plane log types.
	Types []LogType `json:"types,omitempty"`
}

type LogType string

type Logging struct {
	// The cluster control plane logging configuration for your cluster.
	ClusterLogging []LogSetup `json:"clusterLogging"`
}

type OIDC struct {
	// The issuer URL for the OpenID Connect identity provider.
	Issuer string `json:"issuer,omitempty"`
}

type OutpostConfigRequest struct {
	// The Amazon EC2 instance type that you want to use for your local Amazon EKS
	// cluster on Outposts. The instance type that you specify is used for all
	// Kubernetes control plane instances. The instance type can't be changed after
	// cluster creation. Choose an instance type based on the number of nodes that your
	// cluster will have. If your cluster will have:
	//
	// * 1–20 nodes, then we recommend
	// specifying a large instance type.
	//
	// * 21–100 nodes, then we recommend specifying
	// an xlarge instance type.
	//
	// * 101–250 nodes, then we recommend specifying a
	// 2xlarge instance type.
	//
	// For a list of the available Amazon EC2 instance types,
	// see Compute and storage in Outposts rack features
	// (http://aws.amazon.com/outposts/rack/features/). The control plane is not
	// automatically scaled by Amazon EKS.
	//
	// This member is required.
	ControlPlaneInstanceType string `json:"controlPlaneInstanceType"`

	// The ARN of the Outpost that you want to use for your local Amazon EKS cluster on
	// Outposts. Only a single Outpost ARN is supported.
	//
	// This member is required.
	OutpostArns []string `json:"outpostArns"`
}

type OutpostConfigResponse struct {
	// The Amazon EC2 instance type used for the control plane. The instance type is
	// the same for all control plane instances.
	//
	// This member is required.
	ControlPlaneInstanceType string `json:"controlPlaneInstanceType,omitempty"`

	// The ARN of the Outpost that you specified for use with your local Amazon EKS
	// cluster on Outposts.
	//
	// This member is required.
	OutpostArns []string `json:"outpostArns,omitempty"`
}

type Provider struct {

	// Amazon Resource Name (ARN) or alias of the customer master key (CMK). The
	// CMK must be symmetric, created in the same region as the cluster, and if
	// the CMK was created in a different account, the user must have access to
	// the CMK. For more information, see Allowing Users in Other Accounts to Use
	// a CMK (https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying-external-accounts.html)
	// in the AWS Key Management Service Developer Guide.
	KeyArn string `json:"keyArn"`
}

type VpcConfigRequest struct {
	// Set this value to true to enable private access for your cluster's Kubernetes
	// API server endpoint. If you enable private access, Kubernetes API requests
	// from within your cluster's VPC use the private VPC endpoint. The default
	// value for this parameter is false, which disables private access for your
	// Kubernetes API server. For more information, see Amazon EKS Cluster Endpoint
	// Access Control (https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html)
	// in the Amazon EKS User Guide.
	// +optional
	EndpointPrivateAccess *bool `json:"endpointPrivateAccess,omitempty"`

	// Set this value to false to disable public access for your cluster's Kubernetes
	// API server endpoint. If you disable public access, your cluster's Kubernetes
	// API server can receive only requests from within the cluster VPC. The default
	// value for this parameter is true, which enables public access for your Kubernetes
	// API server. For more information, see Amazon EKS Cluster Endpoint Access
	// Control (https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html)
	// in the Amazon EKS User Guide.
	// +optional
	EndpointPublicAccess *bool `json:"endpointPublicAccess,omitempty"`

	// The CIDR blocks that are allowed access to your cluster's public Kubernetes
	// API server endpoint. Communication to the endpoint from addresses outside
	// of the CIDR blocks that you specify is denied. The default value is 0.0.0.0/0.
	// If you've disabled private endpoint access and you have worker nodes or AWS
	// Fargate pods in the cluster, then ensure that you specify the necessary CIDR
	// blocks. For more information, see Amazon EKS Cluster Endpoint Access Control
	// (https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html)
	// in the Amazon EKS User Guide.
	// +optional
	PublicAccessCidrs []string `json:"publicAccessCidrs,omitempty"`

	// Specify one or more security groups for the cross-account elastic network
	// interfaces that Amazon EKS creates to use to allow communication between
	// your worker nodes and the Kubernetes control plane. If you don't specify
	// a security group, the default security group for your VPC is used.
	// +immutable
	// +optional
	// +crossplane:generate:reference:type=github.com/crossplane-contrib/provider-aws/apis/ec2/v1beta1.SecurityGroup
	// +crossplane:generate:reference:refFieldName=SecurityGroupIDRefs
	// +crossplane:generate:reference:selectorFieldName=SecurityGroupIDSelector
	SecurityGroupIDs []string `json:"securityGroupIds,omitempty"`

	// SecurityGroupIDRefs are references to SecurityGroups used to set
	// the SecurityGroupIDs.
	// +optional
	SecurityGroupIDRefs []xpv1.Reference `json:"securityGroupIdRefs,omitempty"`

	// SecurityGroupIDSelector selects references to SecurityGroups used
	// to set the SecurityGroupIDs.
	// +optional
	SecurityGroupIDSelector *xpv1.Selector `json:"securityGroupIdSelector,omitempty"`

	// Specify subnets for your Amazon EKS worker nodes. Amazon EKS creates cross-account
	// elastic network interfaces in these subnets to allow communication between
	// your worker nodes and the Kubernetes control plane.
	// +immutable
	// +optional
	// +crossplane:generate:reference:type=github.com/crossplane-contrib/provider-aws/apis/ec2/v1beta1.Subnet
	// +crossplane:generate:reference:refFieldName=SubnetIDRefs
	// +crossplane:generate:reference:selectorFieldName=SubnetIDSelector
	SubnetIDs []string `json:"subnetIds,omitempty"`

	// SubnetIDRefs are references to Subnets used to set
	// the SubnetIDs.
	// +optional
	SubnetIDRefs []xpv1.Reference `json:"subnetIdRefs,omitempty"`

	// SubnetIDSelector selects references to Subnets used
	// to set the SubnetIDs.
	// +optional
	SubnetIDSelector *xpv1.Selector `json:"subnetIdSelector,omitempty"`
}

type VpcConfigResponse struct {
	// The cluster security group that was created by Amazon EKS for the cluster.
	// Managed node groups use this security group for control-plane-to-data-plane
	// communication.
	ClusterSecurityGroupID string `json:"clusterSecurityGroupId,omitempty"`

	// The VPC associated with your cluster.
	VpcID string `json:"vpcId,omitempty"`
}