@aws-sdk/client-eks 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/AssociateIdentityProviderConfigCommand.d.ts

@@ -6,36 +6,11 @@ export interface AssociateIdentityProviderConfigCommandInput extends AssociateId
 }
 export interface AssociateIdentityProviderConfigCommandOutput extends AssociateIdentityProviderConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Associate an identity provider configuration to a cluster.</p>
- *         <p>If you want to authenticate identities using an identity provider, you can create an
- *             identity provider configuration and associate it to your cluster. After configuring
- *             authentication to your cluster you can create Kubernetes <code>roles</code> and
- *                 <code>clusterroles</code> to assign permissions to the roles, and then bind the
- *             roles to the identities using Kubernetes <code>rolebindings</code> and
- *                 <code>clusterrolebindings</code>. For more information see <a href="https://kubernetes.io/docs/reference/access-authn-authz/rbac/">Using RBAC
- *                 Authorization</a> in the Kubernetes documentation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, AssociateIdentityProviderConfigCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, AssociateIdentityProviderConfigCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new AssociateIdentityProviderConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateIdentityProviderConfigCommandInput} for command's `input` shape.
- * @see {@link AssociateIdentityProviderConfigCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateIdentityProviderConfigCommand extends $Command<AssociateIdentityProviderConfigCommandInput, AssociateIdentityProviderConfigCommandOutput, EKSClientResolvedConfig> {
     readonly input: AssociateIdentityProviderConfigCommandInput;
     constructor(input: AssociateIdentityProviderConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateIdentityProviderConfigCommandInput, AssociateIdentityProviderConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateAddonCommand.d.ts

@@ -6,34 +6,11 @@ export interface CreateAddonCommandInput extends CreateAddonRequest {
 }
 export interface CreateAddonCommandOutput extends CreateAddonResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon EKS add-on.</p>
- *         <p>Amazon EKS add-ons help to automate the provisioning and lifecycle management of common
- *             operational software for Amazon EKS clusters. Amazon EKS add-ons can only be used with Amazon EKS
- *             clusters running version 1.18 with platform version <code>eks.3</code> or later because
- *             add-ons rely on the Server-side Apply Kubernetes feature, which is only available in
- *             Kubernetes 1.18 and later.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, CreateAddonCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, CreateAddonCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new CreateAddonCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAddonCommandInput} for command's `input` shape.
- * @see {@link CreateAddonCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAddonCommand extends $Command<CreateAddonCommandInput, CreateAddonCommandOutput, EKSClientResolvedConfig> {
     readonly input: CreateAddonCommandInput;
     constructor(input: CreateAddonCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAddonCommandInput, CreateAddonCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateClusterCommand.d.ts

@@ -6,47 +6,11 @@ export interface CreateClusterCommandInput extends CreateClusterRequest {
 }
 export interface CreateClusterCommandOutput extends CreateClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon EKS control plane. </p>
- *         <p>The Amazon EKS control plane consists of control plane instances that run the Kubernetes
- *             software, such as <code>etcd</code> and the API server. The control plane runs in an
- *             account managed by Amazon Web Services, and the Kubernetes API is exposed via the Amazon EKS API server
- *             endpoint. Each Amazon EKS cluster control plane is single-tenant and unique and runs on its
- *             own set of Amazon EC2 instances.</p>
- *         <p>The cluster control plane is provisioned across multiple Availability Zones and
- *             fronted by an Elastic Load Balancing Network Load Balancer. Amazon EKS also provisions elastic network interfaces in your VPC
- *             subnets to provide connectivity from the control plane instances to the nodes (for
- *             example, to support <code>kubectl exec</code>, <code>logs</code>, and <code>proxy</code>
- *             data flows).</p>
- *         <p>Amazon EKS nodes run in your Amazon Web Services account and connect to your cluster's control plane via
- *             the Kubernetes API server endpoint and a certificate file that is created for your
- *             cluster.</p>
- *
- *         <p>Cluster creation typically takes several minutes. After you create an Amazon EKS cluster,
- *             you must configure your Kubernetes tooling to communicate with the API server and launch
- *             nodes into your cluster. For more information, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/managing-auth.html">Managing Cluster
- *                 Authentication</a> and <a href="https://docs.aws.amazon.com/eks/latest/userguide/launch-workers.html">Launching Amazon EKS nodes</a> in the <i>Amazon EKS User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, CreateClusterCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, CreateClusterCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new CreateClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateClusterCommandInput} for command's `input` shape.
- * @see {@link CreateClusterCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateClusterCommand extends $Command<CreateClusterCommandInput, CreateClusterCommandOutput, EKSClientResolvedConfig> {
     readonly input: CreateClusterCommandInput;
     constructor(input: CreateClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterCommandInput, CreateClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateFargateProfileCommand.d.ts

@@ -6,52 +6,11 @@ export interface CreateFargateProfileCommandInput extends CreateFargateProfileRe
 }
 export interface CreateFargateProfileCommandOutput extends CreateFargateProfileResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Fargate profile for your Amazon EKS cluster. You must have at least one Fargate
- *             profile in a cluster to be able to run pods on Fargate.</p>
- *         <p>The Fargate profile allows an administrator to declare which pods run on Fargate and specify
- *             which pods run on which Fargate profile. This declaration is done through the profile’s
- *             selectors. Each profile can have up to five selectors that contain a namespace and
- *             labels. A namespace is required for every selector. The label field consists of multiple
- *             optional key-value pairs. Pods that match the selectors are scheduled on Fargate. If a
- *             to-be-scheduled pod matches any of the selectors in the Fargate profile, then that pod is
- *             run on Fargate.</p>
- *         <p>When you create a Fargate profile, you must specify a pod execution role to use with the
- *             pods that are scheduled with the profile. This role is added to the cluster's Kubernetes
- *                 <a href="https://kubernetes.io/docs/admin/authorization/rbac/">Role Based Access
- *                 Control</a> (RBAC) for authorization so that the <code>kubelet</code> that is
- *             running on the Fargate infrastructure can register with your Amazon EKS cluster so that it can
- *             appear in your cluster as a node. The pod execution role also provides IAM permissions
- *             to the Fargate infrastructure to allow read access to Amazon ECR image repositories. For more
- *             information, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/pod-execution-role.html">Pod Execution Role</a> in the <i>Amazon EKS User Guide</i>.</p>
- *         <p>Fargate profiles are immutable. However, you can create a new updated profile to replace
- *             an existing profile and then delete the original after the updated profile has finished
- *             creating.</p>
- *         <p>If any Fargate profiles in a cluster are in the <code>DELETING</code> status, you must
- *             wait for that Fargate profile to finish deleting before you can create any other profiles
- *             in that cluster.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html">Fargate Profile</a> in the <i>Amazon EKS User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, CreateFargateProfileCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, CreateFargateProfileCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new CreateFargateProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFargateProfileCommandInput} for command's `input` shape.
- * @see {@link CreateFargateProfileCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateFargateProfileCommand extends $Command<CreateFargateProfileCommandInput, CreateFargateProfileCommandOutput, EKSClientResolvedConfig> {
     readonly input: CreateFargateProfileCommandInput;
     constructor(input: CreateFargateProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFargateProfileCommandInput, CreateFargateProfileCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateNodegroupCommand.d.ts

@@ -6,38 +6,11 @@ export interface CreateNodegroupCommandInput extends CreateNodegroupRequest {
 }
 export interface CreateNodegroupCommandOutput extends CreateNodegroupResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a managed node group for an Amazon EKS cluster. You can only create a node group
- *             for your cluster that is equal to the current Kubernetes version for the cluster. All
- *             node groups are created with the latest AMI release version for the respective minor
- *             Kubernetes version of the cluster, unless you deploy a custom AMI using a launch
- *             template. For more information about using launch templates, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/launch-templates.html">Launch
- *                 template support</a>.</p>
- *         <p>An Amazon EKS managed node group is an Amazon EC2 Auto Scaling group and associated Amazon EC2 instances that
- *             are managed by Amazon Web Services for an Amazon EKS cluster. Each node group uses a version of the Amazon EKS
- *             optimized Amazon Linux 2 AMI. For more information, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html">Managed
- *                 Node Groups</a> in the <i>Amazon EKS User Guide</i>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, CreateNodegroupCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, CreateNodegroupCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new CreateNodegroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNodegroupCommandInput} for command's `input` shape.
- * @see {@link CreateNodegroupCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNodegroupCommand extends $Command<CreateNodegroupCommandInput, CreateNodegroupCommandOutput, EKSClientResolvedConfig> {
     readonly input: CreateNodegroupCommandInput;
     constructor(input: CreateNodegroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNodegroupCommandInput, CreateNodegroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteAddonCommand.d.ts

@@ -6,31 +6,11 @@ export interface DeleteAddonCommandInput extends DeleteAddonRequest {
 }
 export interface DeleteAddonCommandOutput extends DeleteAddonResponse, __MetadataBearer {
 }
-/**
- * <p>Delete an Amazon EKS add-on.</p>
- *         <p>When you remove the add-on, it will also be deleted from the cluster. You can always
- *             manually start an add-on on the cluster using the Kubernetes API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DeleteAddonCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DeleteAddonCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DeleteAddonCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAddonCommandInput} for command's `input` shape.
- * @see {@link DeleteAddonCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAddonCommand extends $Command<DeleteAddonCommandInput, DeleteAddonCommandOutput, EKSClientResolvedConfig> {
     readonly input: DeleteAddonCommandInput;
     constructor(input: DeleteAddonCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAddonCommandInput, DeleteAddonCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteClusterCommand.d.ts

@@ -6,36 +6,11 @@ export interface DeleteClusterCommandInput extends DeleteClusterRequest {
 }
 export interface DeleteClusterCommandOutput extends DeleteClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the Amazon EKS cluster control plane.</p>
- *         <p>If you have active services in your cluster that are associated with a load balancer,
- *             you must delete those services before deleting the cluster so that the load balancers
- *             are deleted properly. Otherwise, you can have orphaned resources in your VPC that
- *             prevent you from being able to delete the VPC. For more information, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/delete-cluster.html">Deleting a
- *                 Cluster</a> in the <i>Amazon EKS User Guide</i>.</p>
- *         <p>If you have managed node groups or Fargate profiles attached to the cluster, you must
- *             delete them first. For more information, see <a>DeleteNodegroup</a> and <a>DeleteFargateProfile</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DeleteClusterCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DeleteClusterCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DeleteClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteClusterCommand extends $Command<DeleteClusterCommandInput, DeleteClusterCommandOutput, EKSClientResolvedConfig> {
     readonly input: DeleteClusterCommandInput;
     constructor(input: DeleteClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterCommandInput, DeleteClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteFargateProfileCommand.d.ts

@@ -6,36 +6,11 @@ export interface DeleteFargateProfileCommandInput extends DeleteFargateProfileRe
 }
 export interface DeleteFargateProfileCommandOutput extends DeleteFargateProfileResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Fargate profile.</p>
- *         <p>When you delete a Fargate profile, any pods running on Fargate that were created with the
- *             profile are deleted. If those pods match another Fargate profile, then they are scheduled
- *             on Fargate with that profile. If they no longer match any Fargate profiles, then they are not
- *             scheduled on Fargate and they may remain in a pending state.</p>
- *         <p>Only one Fargate profile in a cluster can be in the <code>DELETING</code> status at a
- *             time. You must wait for a Fargate profile to finish deleting before you can delete any
- *             other profiles in that cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DeleteFargateProfileCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DeleteFargateProfileCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DeleteFargateProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFargateProfileCommandInput} for command's `input` shape.
- * @see {@link DeleteFargateProfileCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteFargateProfileCommand extends $Command<DeleteFargateProfileCommandInput, DeleteFargateProfileCommandOutput, EKSClientResolvedConfig> {
     readonly input: DeleteFargateProfileCommandInput;
     constructor(input: DeleteFargateProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFargateProfileCommandInput, DeleteFargateProfileCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteNodegroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteNodegroupCommandInput extends DeleteNodegroupRequest {
 }
 export interface DeleteNodegroupCommandOutput extends DeleteNodegroupResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Amazon EKS node group for a cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DeleteNodegroupCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DeleteNodegroupCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DeleteNodegroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteNodegroupCommandInput} for command's `input` shape.
- * @see {@link DeleteNodegroupCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteNodegroupCommand extends $Command<DeleteNodegroupCommandInput, DeleteNodegroupCommandOutput, EKSClientResolvedConfig> {
     readonly input: DeleteNodegroupCommandInput;
     constructor(input: DeleteNodegroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNodegroupCommandInput, DeleteNodegroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeregisterClusterCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeregisterClusterCommandInput extends DeregisterClusterRequest
 }
 export interface DeregisterClusterCommandOutput extends DeregisterClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Deregisters a connected cluster to remove it from the Amazon EKS control plane.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DeregisterClusterCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DeregisterClusterCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DeregisterClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterClusterCommandInput} for command's `input` shape.
- * @see {@link DeregisterClusterCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterClusterCommand extends $Command<DeregisterClusterCommandInput, DeregisterClusterCommandOutput, EKSClientResolvedConfig> {
     readonly input: DeregisterClusterCommandInput;
     constructor(input: DeregisterClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterClusterCommandInput, DeregisterClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeAddonCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeAddonCommandInput extends DescribeAddonRequest {
 }
 export interface DescribeAddonCommandOutput extends DescribeAddonResponse, __MetadataBearer {
 }
-/**
- * <p>Describes an Amazon EKS add-on.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DescribeAddonCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DescribeAddonCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DescribeAddonCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAddonCommandInput} for command's `input` shape.
- * @see {@link DescribeAddonCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAddonCommand extends $Command<DescribeAddonCommandInput, DescribeAddonCommandOutput, EKSClientResolvedConfig> {
     readonly input: DescribeAddonCommandInput;
     constructor(input: DescribeAddonCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAddonCommandInput, DescribeAddonCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeAddonVersionsCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeAddonVersionsCommandInput extends DescribeAddonVersions
 }
 export interface DescribeAddonVersionsCommandOutput extends DescribeAddonVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the Kubernetes versions that the add-on can be used with.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DescribeAddonVersionsCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DescribeAddonVersionsCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DescribeAddonVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAddonVersionsCommandInput} for command's `input` shape.
- * @see {@link DescribeAddonVersionsCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAddonVersionsCommand extends $Command<DescribeAddonVersionsCommandInput, DescribeAddonVersionsCommandOutput, EKSClientResolvedConfig> {
     readonly input: DescribeAddonVersionsCommandInput;
     constructor(input: DescribeAddonVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAddonVersionsCommandInput, DescribeAddonVersionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeClusterCommand.d.ts

@@ -6,37 +6,11 @@ export interface DescribeClusterCommandInput extends DescribeClusterRequest {
 }
 export interface DescribeClusterCommandOutput extends DescribeClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Returns descriptive information about an Amazon EKS cluster.</p>
- *         <p>The API server endpoint and certificate authority data returned by this operation are
- *             required for <code>kubelet</code> and <code>kubectl</code> to communicate with your
- *             Kubernetes API server. For more information, see <a href="https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html">Create a
- *                 kubeconfig for Amazon EKS</a>.</p>
- *         <note>
- *             <p>The API server endpoint and certificate authority data aren't available until the
- *                 cluster reaches the <code>ACTIVE</code> state.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DescribeClusterCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DescribeClusterCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DescribeClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClusterCommandInput} for command's `input` shape.
- * @see {@link DescribeClusterCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClusterCommand extends $Command<DescribeClusterCommandInput, DescribeClusterCommandOutput, EKSClientResolvedConfig> {
     readonly input: DescribeClusterCommandInput;
     constructor(input: DescribeClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClusterCommandInput, DescribeClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeFargateProfileCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeFargateProfileCommandInput extends DescribeFargateProfi
 }
 export interface DescribeFargateProfileCommandOutput extends DescribeFargateProfileResponse, __MetadataBearer {
 }
-/**
- * <p>Returns descriptive information about an Fargate profile.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DescribeFargateProfileCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DescribeFargateProfileCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DescribeFargateProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFargateProfileCommandInput} for command's `input` shape.
- * @see {@link DescribeFargateProfileCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFargateProfileCommand extends $Command<DescribeFargateProfileCommandInput, DescribeFargateProfileCommandOutput, EKSClientResolvedConfig> {
     readonly input: DescribeFargateProfileCommandInput;
     constructor(input: DescribeFargateProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFargateProfileCommandInput, DescribeFargateProfileCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeIdentityProviderConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeIdentityProviderConfigCommandInput extends DescribeIden
 }
 export interface DescribeIdentityProviderConfigCommandOutput extends DescribeIdentityProviderConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Returns descriptive information about an identity provider configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DescribeIdentityProviderConfigCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DescribeIdentityProviderConfigCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DescribeIdentityProviderConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeIdentityProviderConfigCommandInput} for command's `input` shape.
- * @see {@link DescribeIdentityProviderConfigCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeIdentityProviderConfigCommand extends $Command<DescribeIdentityProviderConfigCommandInput, DescribeIdentityProviderConfigCommandOutput, EKSClientResolvedConfig> {
     readonly input: DescribeIdentityProviderConfigCommandInput;
     constructor(input: DescribeIdentityProviderConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeIdentityProviderConfigCommandInput, DescribeIdentityProviderConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeNodegroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeNodegroupCommandInput extends DescribeNodegroupRequest
 }
 export interface DescribeNodegroupCommandOutput extends DescribeNodegroupResponse, __MetadataBearer {
 }
-/**
- * <p>Returns descriptive information about an Amazon EKS node group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EKSClient, DescribeNodegroupCommand } from "@aws-sdk/client-eks"; // ES Modules import
- * // const { EKSClient, DescribeNodegroupCommand } = require("@aws-sdk/client-eks"); // CommonJS import
- * const client = new EKSClient(config);
- * const command = new DescribeNodegroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeNodegroupCommandInput} for command's `input` shape.
- * @see {@link DescribeNodegroupCommandOutput} for command's `response` shape.
- * @see {@link EKSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeNodegroupCommand extends $Command<DescribeNodegroupCommandInput, DescribeNodegroupCommandOutput, EKSClientResolvedConfig> {
     readonly input: DescribeNodegroupCommandInput;
     constructor(input: DescribeNodegroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EKSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeNodegroupCommandInput, DescribeNodegroupCommandOutput>;
     private serialize;
     private deserialize;