const ServiceAPIVersion = "2017-11-01"

const ServiceID = "EKS"

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

type CreateClusterInput struct {

	// 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/).
	Logging *types.Logging

	// The unique name to give to your cluster.
	//
	// This member is required.
	Name *string

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string

	// The encryption configuration for the cluster.
	EncryptionConfig []*types.EncryptionConfig

	// 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.
	Tags map[string]*string

	// The desired Kubernetes version for your cluster. If you don't specify a value
	// here, the latest version available in Amazon EKS is used.
	Version *string

	// 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 .
	//
	// This member is required.
	RoleArn *string

	// 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.
	//
	// This member is required.
	ResourcesVpcConfig *types.VpcConfigRequest
}

type CreateClusterOutput struct {

	// The full description of your new cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateFargateProfileInput struct {

	// 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.
	Subnets []*string

	// 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.
	Selectors []*types.FargateProfileSelector

	// 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.
	Tags map[string]*string

	// 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.
	//
	// This member is required.
	PodExecutionRoleArn *string

	// The name of the Fargate profile.
	//
	// This member is required.
	FargateProfileName *string

	// The name of the Amazon EKS cluster to apply the Fargate profile to.
	//
	// This member is required.
	ClusterName *string

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string
}

type CreateFargateProfileOutput struct {

	// The full description of your new Fargate profile.
	FargateProfile *types.FargateProfile

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateNodegroupInput struct {

	// The subnets to use for the Auto Scaling group that is created for your node
	// group. These subnets must have the tag key kubernetes.io/cluster/CLUSTER_NAME
	// with a value of shared, where CLUSTER_NAME is replaced with the name of your
	// cluster.
	//
	// This member is required.
	Subnets []*string

	// The unique name to give your node group.
	//
	// This member is required.
	NodegroupName *string

	// The AMI type for your node group. GPU instance types should use the
	// AL2_x86_64_GPU AMI type, which uses the Amazon EKS-optimized Linux AMI with GPU
	// support. Non-GPU instances should use the AL2_x86_64 AMI type, which uses the
	// Amazon EKS-optimized Linux AMI.
	AmiType types.AMITypes

	// The Amazon Resource Name (ARN) of the IAM role to associate with your node
	// group. The Amazon EKS worker node kubelet daemon makes calls to AWS APIs on your
	// behalf. Worker nodes receive permissions for these API calls through an IAM
	// instance profile and associated policies. Before you can launch worker nodes and
	// register them into a cluster, you must create an IAM role for those worker nodes
	// to use when they are launched. For more information, see Amazon EKS Worker Node
	// IAM Role
	// (https://docs.aws.amazon.com/eks/latest/userguide/worker_node_IAM_role.html) in
	// the Amazon EKS User Guide .
	//
	// This member is required.
	NodeRole *string

	// The instance type to use for your node group. Currently, you can specify a
	// single instance type for a node group. The default value for this parameter is
	// t3.medium. If you choose a GPU instance type, be sure to specify the
	// AL2_x86_64_GPU with the amiType parameter.
	InstanceTypes []*string

	// The AMI version of the Amazon EKS-optimized AMI to use with your node group. By
	// default, the latest available AMI version for the node group's current
	// Kubernetes version is used. For more information, see Amazon EKS-Optimized Linux
	// AMI Versions
	// (https://docs.aws.amazon.com/eks/latest/userguide/eks-linux-ami-versions.html)
	// in the Amazon EKS User Guide.
	ReleaseVersion *string

	// The remote access (SSH) configuration to use with your node group.
	RemoteAccess *types.RemoteAccessConfig

	// The scaling configuration details for the Auto Scaling group that is created for
	// your node group.
	ScalingConfig *types.NodegroupScalingConfig

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string

	// The name of the cluster to create the node group in.
	//
	// This member is required.
	ClusterName *string

	// The root device disk size (in GiB) for your node group instances. The default
	// disk size is 20 GiB.
	DiskSize *int32

	// The Kubernetes version to use for your managed nodes. By default, the Kubernetes
	// version of the cluster is used, and this is the only accepted specified value.
	Version *string

	// The metadata to apply to the node group to assist with categorization and
	// organization. Each tag consists of a key and an optional value, both of which
	// you define. Node group tags do not propagate to any other resources associated
	// with the node group, such as the Amazon EC2 instances or subnets.
	Tags map[string]*string

	// The Kubernetes labels to be applied to the nodes in the node group when they are
	// created.
	Labels map[string]*string
}

type CreateNodegroupOutput struct {

	// The full description of your new node group.
	Nodegroup *types.Nodegroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteClusterInput struct {

	// The name of the cluster to delete.
	//
	// This member is required.
	Name *string
}

type DeleteClusterOutput struct {

	// The full description of the cluster to delete.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteFargateProfileInput struct {

	// The name of the Fargate profile to delete.
	//
	// This member is required.
	FargateProfileName *string

	// The name of the Amazon EKS cluster associated with the Fargate profile to
	// delete.
	//
	// This member is required.
	ClusterName *string
}

type DeleteFargateProfileOutput struct {

	// The deleted Fargate profile.
	FargateProfile *types.FargateProfile

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteNodegroupInput struct {

	// The name of the node group to delete.
	//
	// This member is required.
	NodegroupName *string

	// The name of the Amazon EKS cluster that is associated with your node group.
	//
	// This member is required.
	ClusterName *string
}

type DeleteNodegroupOutput struct {

	// The full description of your deleted node group.
	Nodegroup *types.Nodegroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeClusterInput struct {

	// The name of the cluster to describe.
	//
	// This member is required.
	Name *string
}

type DescribeClusterOutput struct {

	// The full description of your specified cluster.
	Cluster *types.Cluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeFargateProfileInput struct {

	// The name of the Fargate profile to describe.
	//
	// This member is required.
	FargateProfileName *string

	// The name of the Amazon EKS cluster associated with the Fargate profile.
	//
	// This member is required.
	ClusterName *string
}

type DescribeFargateProfileOutput struct {

	// The full description of your Fargate profile.
	FargateProfile *types.FargateProfile

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeNodegroupInput struct {

	// The name of the node group to describe.
	//
	// This member is required.
	NodegroupName *string

	// The name of the Amazon EKS cluster associated with the node group.
	//
	// This member is required.
	ClusterName *string
}

type DescribeNodegroupOutput struct {

	// The full description of your node group.
	Nodegroup *types.Nodegroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeUpdateInput struct {

	// The ID of the update to describe.
	//
	// This member is required.
	UpdateId *string

	// The name of the Amazon EKS node group associated with the update.
	NodegroupName *string

	// The name of the Amazon EKS cluster associated with the update.
	//
	// This member is required.
	Name *string
}

type DescribeUpdateOutput struct {

	// The full description of the specified update.
	Update *types.Update

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type IdempotencyTokenProvider interface {
	GetIdempotencyToken() (string, error)
}

type ListClustersInput struct {

	// The maximum number of cluster results returned by ListClusters in paginated
	// output. When you use this parameter, ListClusters returns only maxResults
	// results in a single page along with a nextToken response element. You can see
	// the remaining results of the initial request by sending another ListClusters
	// request with the returned nextToken value. This value can be between 1 and 100.
	// If you don't use this parameter, ListClusters returns up to 100 results and a
	// nextToken value if applicable.
	MaxResults *int32

	// The nextToken value returned from a previous paginated ListClusters request
	// where maxResults was used and the results exceeded the value of that parameter.
	// Pagination continues from the end of the previous results that returned the
	// nextToken value. This token should be treated as an opaque identifier that is
	// used only to retrieve the next items in a list and not for other programmatic
	// purposes.
	NextToken *string
}

type ListClustersOutput struct {

	// A list of all of the clusters for your account in the specified Region.
	Clusters []*string

	// The nextToken value to include in a future ListClusters request. When the
	// results of a ListClusters request exceed maxResults, you can use this value to
	// retrieve the next page of results. This value is null when there are no more
	// results to return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListFargateProfilesInput struct {

	// The name of the Amazon EKS cluster that you would like to listFargate profiles
	// in.
	//
	// This member is required.
	ClusterName *string

	// The maximum number of Fargate profile results returned by ListFargateProfiles in
	// paginated output. When you use this parameter, ListFargateProfiles returns only
	// maxResults results in a single page along with a nextToken response element. You
	// can see the remaining results of the initial request by sending another
	// ListFargateProfiles request with the returned nextToken value. This value can be
	// between 1 and 100. If you don't use this parameter, ListFargateProfiles returns
	// up to 100 results and a nextToken value if applicable.
	MaxResults *int32

	// The nextToken value returned from a previous paginated ListFargateProfiles
	// request where maxResults was used and the results exceeded the value of that
	// parameter. Pagination continues from the end of the previous results that
	// returned the nextToken value.
	NextToken *string
}

type ListFargateProfilesOutput struct {

	// The nextToken value to include in a future ListFargateProfiles request. When the
	// results of a ListFargateProfiles request exceed maxResults, you can use this
	// value to retrieve the next page of results. This value is null when there are no
	// more results to return.
	NextToken *string

	// A list of all of the Fargate profiles associated with the specified cluster.
	FargateProfileNames []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListNodegroupsInput struct {

	// The nextToken value returned from a previous paginated ListNodegroups request
	// where maxResults was used and the results exceeded the value of that parameter.
	// Pagination continues from the end of the previous results that returned the
	// nextToken value.
	NextToken *string

	// The name of the Amazon EKS cluster that you would like to list node groups in.
	//
	// This member is required.
	ClusterName *string

	// The maximum number of node group results returned by ListNodegroups in paginated
	// output. When you use this parameter, ListNodegroups returns only maxResults
	// results in a single page along with a nextToken response element. You can see
	// the remaining results of the initial request by sending another ListNodegroups
	// request with the returned nextToken value. This value can be between 1 and 100.
	// If you don't use this parameter, ListNodegroups returns up to 100 results and a
	// nextToken value if applicable.
	MaxResults *int32
}

type ListNodegroupsOutput struct {

	// A list of all of the node groups associated with the specified cluster.
	Nodegroups []*string

	// The nextToken value to include in a future ListNodegroups request. When the
	// results of a ListNodegroups request exceed maxResults, you can use this value to
	// retrieve the next page of results. This value is null when there are no more
	// results to return.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTagsForResourceInput struct {

	// The Amazon Resource Name (ARN) that identifies the resource for which to list
	// the tags. Currently, the supported resources are Amazon EKS clusters and managed
	// node groups.
	//
	// This member is required.
	ResourceArn *string
}

type ListTagsForResourceOutput struct {

	// The tags for the resource.
	Tags map[string]*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUpdatesInput struct {

	// The nextToken value returned from a previous paginated ListUpdates request where
	// maxResults was used and the results exceeded the value of that parameter.
	// Pagination continues from the end of the previous results that returned the
	// nextToken value.
	NextToken *string

	// The maximum number of update results returned by ListUpdates in paginated
	// output. When you use this parameter, ListUpdates returns only maxResults results
	// in a single page along with a nextToken response element. You can see the
	// remaining results of the initial request by sending another ListUpdates request
	// with the returned nextToken value. This value can be between 1 and 100. If you
	// don't use this parameter, ListUpdates returns up to 100 results and a nextToken
	// value if applicable.
	MaxResults *int32

	// The name of the Amazon EKS managed node group to list updates for.
	NodegroupName *string

	// The name of the Amazon EKS cluster to list updates for.
	//
	// This member is required.
	Name *string
}

type ListUpdatesOutput struct {

	// The nextToken value to include in a future ListUpdates request. When the results
	// of a ListUpdates request exceed maxResults, you can use this value to retrieve
	// the next page of results. This value is null when there are no more results to
	// return.
	NextToken *string

	// A list of all the updates for the specified cluster and Region.
	UpdateIds []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// Provides idempotency tokens values that will be automatically populated into
	// idempotent API operations.
	IdempotencyTokenProvider IdempotencyTokenProvider

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type TagResourceInput struct {

	// The tags to add to the resource. A tag is an array of key-value pairs.
	//
	// This member is required.
	Tags map[string]*string

	// The Amazon Resource Name (ARN) of the resource to which to add tags. Currently,
	// the supported resources are Amazon EKS clusters and managed node groups.
	//
	// This member is required.
	ResourceArn *string
}

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

type UntagResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource from which to delete tags.
	// Currently, the supported resources are Amazon EKS clusters and managed node
	// groups.
	//
	// This member is required.
	ResourceArn *string

	// The keys of the tags to be removed.
	//
	// This member is required.
	TagKeys []*string
}

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

type UpdateClusterConfigInput struct {

	// An object representing the VPC configuration to use for an Amazon EKS cluster.
	ResourcesVpcConfig *types.VpcConfigRequest

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string

	// 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/).
	Logging *types.Logging

	// The name of the Amazon EKS cluster to update.
	//
	// This member is required.
	Name *string
}

type UpdateClusterConfigOutput struct {

	// An object representing an asynchronous update.
	Update *types.Update

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateClusterVersionInput struct {

	// The name of the Amazon EKS cluster to update.
	//
	// This member is required.
	Name *string

	// The desired Kubernetes version following a successful update.
	//
	// This member is required.
	Version *string

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string
}

type UpdateClusterVersionOutput struct {

	// The full description of the specified update
	Update *types.Update

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateNodegroupConfigInput struct {

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string

	// The scaling configuration details for the Auto Scaling group after the update.
	ScalingConfig *types.NodegroupScalingConfig

	// The name of the managed node group to update.
	//
	// This member is required.
	NodegroupName *string

	// The Kubernetes labels to be applied to the nodes in the node group after the
	// update.
	Labels *types.UpdateLabelsPayload

	// The name of the Amazon EKS cluster that the managed node group resides in.
	//
	// This member is required.
	ClusterName *string
}

type UpdateNodegroupConfigOutput struct {

	// An object representing an asynchronous update.
	Update *types.Update

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateNodegroupVersionInput struct {

	// The AMI version of the Amazon EKS-optimized AMI to use for the update. By
	// default, the latest available AMI version for the node group's Kubernetes
	// version is used. For more information, see Amazon EKS-Optimized Linux AMI
	// Versions
	// (https://docs.aws.amazon.com/eks/latest/userguide/eks-linux-ami-versions.html)
	// in the Amazon EKS User Guide.
	ReleaseVersion *string

	// Force the update if the existing node group's pods are unable to be drained due
	// to a pod disruption budget issue. If an update fails because pods could not be
	// drained, you can force the update after it fails to terminate the old node
	// whether or not any pods are running on the node.
	Force *bool

	// Unique, case-sensitive identifier that you provide to ensure the idempotency of
	// the request.
	ClientRequestToken *string

	// The Kubernetes version to update to. If no version is specified, then the
	// Kubernetes version of the node group does not change. You can specify the
	// Kubernetes version of the cluster to update the node group to the latest AMI
	// version of the cluster's Kubernetes version.
	Version *string

	// The name of the Amazon EKS cluster that is associated with the managed node
	// group to update.
	//
	// This member is required.
	ClusterName *string

	// The name of the managed node group to update.
	//
	// This member is required.
	NodegroupName *string
}

type UpdateNodegroupVersionOutput struct {

	// An object representing an asynchronous update.
	Update *types.Update

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}