@aws-sdk/client-eks 3.35.0 → 3.38.0

package/src/commands/CreateAddonCommand.ts

@@ -1,100 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { EKSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSClient";
-import { CreateAddonRequest, CreateAddonResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateAddonCommand,
-  serializeAws_restJson1CreateAddonCommand,
-} from "../protocols/Aws_restJson1";
-
-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 class CreateAddonCommand extends $Command<
-  CreateAddonCommandInput,
-  CreateAddonCommandOutput,
-  EKSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateAddonCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EKSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateAddonCommandInput, CreateAddonCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "EKSClient";
-    const commandName = "CreateAddonCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateAddonRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateAddonResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateAddonCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateAddonCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateAddonCommandOutput> {
-    return deserializeAws_restJson1CreateAddonCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateClusterCommand.ts

@@ -1,113 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { EKSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSClient";
-import { CreateClusterRequest, CreateClusterResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateClusterCommand,
-  serializeAws_restJson1CreateClusterCommand,
-} from "../protocols/Aws_restJson1";
-
-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 class CreateClusterCommand extends $Command<
-  CreateClusterCommandInput,
-  CreateClusterCommandOutput,
-  EKSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateClusterCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EKSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateClusterCommandInput, CreateClusterCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "EKSClient";
-    const commandName = "CreateClusterCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateClusterRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateClusterResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateClusterCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateClusterCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateClusterCommandOutput> {
-    return deserializeAws_restJson1CreateClusterCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateFargateProfileCommand.ts

@@ -1,118 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { EKSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSClient";
-import { CreateFargateProfileRequest, CreateFargateProfileResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateFargateProfileCommand,
-  serializeAws_restJson1CreateFargateProfileCommand,
-} from "../protocols/Aws_restJson1";
-
-export interface CreateFargateProfileCommandInput extends CreateFargateProfileRequest {}
-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 class CreateFargateProfileCommand extends $Command<
-  CreateFargateProfileCommandInput,
-  CreateFargateProfileCommandOutput,
-  EKSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateFargateProfileCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EKSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateFargateProfileCommandInput, CreateFargateProfileCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "EKSClient";
-    const commandName = "CreateFargateProfileCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateFargateProfileRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateFargateProfileResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateFargateProfileCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateFargateProfileCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateFargateProfileCommandOutput> {
-    return deserializeAws_restJson1CreateFargateProfileCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateNodegroupCommand.ts

@@ -1,104 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { EKSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSClient";
-import { CreateNodegroupRequest, CreateNodegroupResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1CreateNodegroupCommand,
-  serializeAws_restJson1CreateNodegroupCommand,
-} from "../protocols/Aws_restJson1";
-
-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 class CreateNodegroupCommand extends $Command<
-  CreateNodegroupCommandInput,
-  CreateNodegroupCommandOutput,
-  EKSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateNodegroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EKSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateNodegroupCommandInput, CreateNodegroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "EKSClient";
-    const commandName = "CreateNodegroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateNodegroupRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateNodegroupResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateNodegroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1CreateNodegroupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateNodegroupCommandOutput> {
-    return deserializeAws_restJson1CreateNodegroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/DeleteAddonCommand.ts

@@ -1,97 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { EKSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSClient";
-import { DeleteAddonRequest, DeleteAddonResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteAddonCommand,
-  serializeAws_restJson1DeleteAddonCommand,
-} from "../protocols/Aws_restJson1";
-
-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 class DeleteAddonCommand extends $Command<
-  DeleteAddonCommandInput,
-  DeleteAddonCommandOutput,
-  EKSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteAddonCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EKSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteAddonCommandInput, DeleteAddonCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "EKSClient";
-    const commandName = "DeleteAddonCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteAddonRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteAddonResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteAddonCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteAddonCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteAddonCommandOutput> {
-    return deserializeAws_restJson1DeleteAddonCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/DeleteClusterCommand.ts

@@ -1,102 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { EKSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EKSClient";
-import { DeleteClusterRequest, DeleteClusterResponse } from "../models/models_0";
-import {
-  deserializeAws_restJson1DeleteClusterCommand,
-  serializeAws_restJson1DeleteClusterCommand,
-} from "../protocols/Aws_restJson1";
-
-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 class DeleteClusterCommand extends $Command<
-  DeleteClusterCommandInput,
-  DeleteClusterCommandOutput,
-  EKSClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteClusterCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: EKSClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteClusterCommandInput, DeleteClusterCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "EKSClient";
-    const commandName = "DeleteClusterCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteClusterRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteClusterResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteClusterCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restJson1DeleteClusterCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteClusterCommandOutput> {
-    return deserializeAws_restJson1DeleteClusterCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}