@aws-sdk/client-emr-containers 3.35.0 → 3.38.0

package/dist-types/ts3.4/EMRContainers.d.ts

@@ -15,118 +15,65 @@ import { StartJobRunCommandInput, StartJobRunCommandOutput } from "./commands/St
 import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { EMRContainersClient } from "./EMRContainersClient";
-/**
- * <p>Amazon EMR on EKS provides a deployment option for Amazon EMR that allows you to run
- *          open-source big data frameworks on Amazon Elastic Kubernetes Service (Amazon EKS). With
- *          this deployment option, you can focus on running analytics workloads while Amazon EMR on
- *          EKS builds, configures, and manages containers for open-source applications. For more
- *          information about Amazon EMR on EKS concepts and tasks, see <a href="https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks.html">What is Amazon EMR on EKS</a>.</p>
- *          <p>
- *             <i>Amazon EMR containers</i> is the API name for Amazon EMR on EKS. The
- *             <code>emr-containers</code> prefix is used in the following scenarios: </p>
- *          <ul>
- *             <li>
- *                <p>It is the prefix in the CLI commands for Amazon EMR on EKS. For example, <code>aws
- *                   emr-containers start-job-run</code>.</p>
- *             </li>
- *             <li>
- *                <p>It is the prefix before IAM policy actions for Amazon EMR on EKS. For example, <code>"Action": [
- *             "emr-containers:StartJobRun"]</code>. For more information, see <a href="https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-actions">Policy actions for Amazon EMR on EKS</a>.</p>
- *             </li>
- *             <li>
- *                <p>It is the prefix used in Amazon EMR on EKS service endpoints. For example, <code>emr-containers.us-east-2.amazonaws.com</code>. For more
- *             information, see <a href="https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/service-quotas.html#service-endpoints">Amazon EMR on EKS Service Endpoints</a>.</p>
- *             </li>
- *          </ul>
- */
+
 export declare class EMRContainers extends EMRContainersClient {
-    /**
-     * <p>Cancels a job run. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
-     */
+    
     cancelJobRun(args: CancelJobRunCommandInput, options?: __HttpHandlerOptions): Promise<CancelJobRunCommandOutput>;
     cancelJobRun(args: CancelJobRunCommandInput, cb: (err: any, data?: CancelJobRunCommandOutput) => void): void;
     cancelJobRun(args: CancelJobRunCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelJobRunCommandOutput) => void): void;
-    /**
-     * <p>Creates a managed endpoint. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
-     */
+    
     createManagedEndpoint(args: CreateManagedEndpointCommandInput, options?: __HttpHandlerOptions): Promise<CreateManagedEndpointCommandOutput>;
     createManagedEndpoint(args: CreateManagedEndpointCommandInput, cb: (err: any, data?: CreateManagedEndpointCommandOutput) => void): void;
     createManagedEndpoint(args: CreateManagedEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateManagedEndpointCommandOutput) => void): void;
-    /**
-     * <p>Creates a virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
-     */
+    
     createVirtualCluster(args: CreateVirtualClusterCommandInput, options?: __HttpHandlerOptions): Promise<CreateVirtualClusterCommandOutput>;
     createVirtualCluster(args: CreateVirtualClusterCommandInput, cb: (err: any, data?: CreateVirtualClusterCommandOutput) => void): void;
     createVirtualCluster(args: CreateVirtualClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateVirtualClusterCommandOutput) => void): void;
-    /**
-     * <p>Deletes a managed endpoint. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
-     */
+    
     deleteManagedEndpoint(args: DeleteManagedEndpointCommandInput, options?: __HttpHandlerOptions): Promise<DeleteManagedEndpointCommandOutput>;
     deleteManagedEndpoint(args: DeleteManagedEndpointCommandInput, cb: (err: any, data?: DeleteManagedEndpointCommandOutput) => void): void;
     deleteManagedEndpoint(args: DeleteManagedEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteManagedEndpointCommandOutput) => void): void;
-    /**
-     * <p>Deletes a virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
-     */
+    
     deleteVirtualCluster(args: DeleteVirtualClusterCommandInput, options?: __HttpHandlerOptions): Promise<DeleteVirtualClusterCommandOutput>;
     deleteVirtualCluster(args: DeleteVirtualClusterCommandInput, cb: (err: any, data?: DeleteVirtualClusterCommandOutput) => void): void;
     deleteVirtualCluster(args: DeleteVirtualClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteVirtualClusterCommandOutput) => void): void;
-    /**
-     * <p>Displays detailed information about a job run. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
-     */
+    
     describeJobRun(args: DescribeJobRunCommandInput, options?: __HttpHandlerOptions): Promise<DescribeJobRunCommandOutput>;
     describeJobRun(args: DescribeJobRunCommandInput, cb: (err: any, data?: DescribeJobRunCommandOutput) => void): void;
     describeJobRun(args: DescribeJobRunCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeJobRunCommandOutput) => void): void;
-    /**
-     * <p>Displays detailed information about a managed endpoint. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
-     */
+    
     describeManagedEndpoint(args: DescribeManagedEndpointCommandInput, options?: __HttpHandlerOptions): Promise<DescribeManagedEndpointCommandOutput>;
     describeManagedEndpoint(args: DescribeManagedEndpointCommandInput, cb: (err: any, data?: DescribeManagedEndpointCommandOutput) => void): void;
     describeManagedEndpoint(args: DescribeManagedEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeManagedEndpointCommandOutput) => void): void;
-    /**
-     * <p>Displays detailed information about a specified virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
-     */
+    
     describeVirtualCluster(args: DescribeVirtualClusterCommandInput, options?: __HttpHandlerOptions): Promise<DescribeVirtualClusterCommandOutput>;
     describeVirtualCluster(args: DescribeVirtualClusterCommandInput, cb: (err: any, data?: DescribeVirtualClusterCommandOutput) => void): void;
     describeVirtualCluster(args: DescribeVirtualClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeVirtualClusterCommandOutput) => void): void;
-    /**
-     * <p>Lists job runs based on a set of parameters. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
-     */
+    
     listJobRuns(args: ListJobRunsCommandInput, options?: __HttpHandlerOptions): Promise<ListJobRunsCommandOutput>;
     listJobRuns(args: ListJobRunsCommandInput, cb: (err: any, data?: ListJobRunsCommandOutput) => void): void;
     listJobRuns(args: ListJobRunsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListJobRunsCommandOutput) => void): void;
-    /**
-     * <p>Lists managed endpoints based on a set of parameters. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
-     */
+    
     listManagedEndpoints(args: ListManagedEndpointsCommandInput, options?: __HttpHandlerOptions): Promise<ListManagedEndpointsCommandOutput>;
     listManagedEndpoints(args: ListManagedEndpointsCommandInput, cb: (err: any, data?: ListManagedEndpointsCommandOutput) => void): void;
     listManagedEndpoints(args: ListManagedEndpointsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListManagedEndpointsCommandOutput) => void): void;
-    /**
-     * <p>Lists the tags assigned to the resources.</p>
-     */
+    
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
-    /**
-     * <p>Lists information about the specified virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
-     */
+    
     listVirtualClusters(args: ListVirtualClustersCommandInput, options?: __HttpHandlerOptions): Promise<ListVirtualClustersCommandOutput>;
     listVirtualClusters(args: ListVirtualClustersCommandInput, cb: (err: any, data?: ListVirtualClustersCommandOutput) => void): void;
     listVirtualClusters(args: ListVirtualClustersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListVirtualClustersCommandOutput) => void): void;
-    /**
-     * <p>Starts a job run. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
-     */
+    
     startJobRun(args: StartJobRunCommandInput, options?: __HttpHandlerOptions): Promise<StartJobRunCommandOutput>;
     startJobRun(args: StartJobRunCommandInput, cb: (err: any, data?: StartJobRunCommandOutput) => void): void;
     startJobRun(args: StartJobRunCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartJobRunCommandOutput) => void): void;
-    /**
-     * <p>Assigns tags to resources. A tag is a label that you assign to an AWS resource. Each tag consists of a key and an optional value, both of which you define. Tags enable you to categorize your AWS resources by attributes such as purpose, owner, or environment. When you have many resources of the same type, you can quickly identify a specific resource based on the tags you've assigned to it. For example, you can define a set of tags for your Amazon EMR on EKS clusters to help you track each cluster's owner and stack level. We recommend that you devise a consistent set of tag keys for each resource type. You can then search and filter the resources based on the tags that you add.</p>
-     */
+    
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
-    /**
-     * <p>Removes tags from resources.</p>
-     */
+    
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;

package/dist-types/ts3.4/EMRContainersClient.d.ts

@@ -24,145 +24,59 @@ import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./command
 export declare type ServiceInputTypes = CancelJobRunCommandInput | CreateManagedEndpointCommandInput | CreateVirtualClusterCommandInput | DeleteManagedEndpointCommandInput | DeleteVirtualClusterCommandInput | DescribeJobRunCommandInput | DescribeManagedEndpointCommandInput | DescribeVirtualClusterCommandInput | ListJobRunsCommandInput | ListManagedEndpointsCommandInput | ListTagsForResourceCommandInput | ListVirtualClustersCommandInput | StartJobRunCommandInput | TagResourceCommandInput | UntagResourceCommandInput;
 export declare type ServiceOutputTypes = CancelJobRunCommandOutput | CreateManagedEndpointCommandOutput | CreateVirtualClusterCommandOutput | DeleteManagedEndpointCommandOutput | DeleteVirtualClusterCommandOutput | DescribeJobRunCommandOutput | DescribeManagedEndpointCommandOutput | DescribeVirtualClusterCommandOutput | ListJobRunsCommandOutput | ListManagedEndpointsCommandOutput | ListTagsForResourceCommandOutput | ListVirtualClustersCommandOutput | StartJobRunCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type EMRContainersClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of EMRContainersClient class constructor that set the region, credentials and other options.
- */
+
 export interface EMRContainersClientConfig extends EMRContainersClientConfigType {
 }
 declare type EMRContainersClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of EMRContainersClient class. This is resolved and normalized from the {@link EMRContainersClientConfig | constructor configuration interface}.
- */
+
 export interface EMRContainersClientResolvedConfig extends EMRContainersClientResolvedConfigType {
 }
-/**
- * <p>Amazon EMR on EKS provides a deployment option for Amazon EMR that allows you to run
- *          open-source big data frameworks on Amazon Elastic Kubernetes Service (Amazon EKS). With
- *          this deployment option, you can focus on running analytics workloads while Amazon EMR on
- *          EKS builds, configures, and manages containers for open-source applications. For more
- *          information about Amazon EMR on EKS concepts and tasks, see <a href="https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks.html">What is Amazon EMR on EKS</a>.</p>
- *          <p>
- *             <i>Amazon EMR containers</i> is the API name for Amazon EMR on EKS. The
- *             <code>emr-containers</code> prefix is used in the following scenarios: </p>
- *          <ul>
- *             <li>
- *                <p>It is the prefix in the CLI commands for Amazon EMR on EKS. For example, <code>aws
- *                   emr-containers start-job-run</code>.</p>
- *             </li>
- *             <li>
- *                <p>It is the prefix before IAM policy actions for Amazon EMR on EKS. For example, <code>"Action": [
- *             "emr-containers:StartJobRun"]</code>. For more information, see <a href="https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-actions">Policy actions for Amazon EMR on EKS</a>.</p>
- *             </li>
- *             <li>
- *                <p>It is the prefix used in Amazon EMR on EKS service endpoints. For example, <code>emr-containers.us-east-2.amazonaws.com</code>. For more
- *             information, see <a href="https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/service-quotas.html#service-endpoints">Amazon EMR on EKS Service Endpoints</a>.</p>
- *             </li>
- *          </ul>
- */
+
 export declare class EMRContainersClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, EMRContainersClientResolvedConfig> {
-    /**
-     * The resolved configuration of EMRContainersClient class. This is resolved and normalized from the {@link EMRContainersClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: EMRContainersClientResolvedConfig;
     constructor(configuration: EMRContainersClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,29 +6,11 @@ export interface CancelJobRunCommandInput extends CancelJobRunRequest {
 }
 export interface CancelJobRunCommandOutput extends CancelJobRunResponse, __MetadataBearer {
 }
-/**
- * <p>Cancels a job run. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, CancelJobRunCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, CancelJobRunCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new CancelJobRunCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelJobRunCommandInput} for command's `input` shape.
- * @see {@link CancelJobRunCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelJobRunCommand extends $Command<CancelJobRunCommandInput, CancelJobRunCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: CancelJobRunCommandInput;
     constructor(input: CancelJobRunCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelJobRunCommandInput, CancelJobRunCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateManagedEndpointCommandInput extends CreateManagedEndpoint
 }
 export interface CreateManagedEndpointCommandOutput extends CreateManagedEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a managed endpoint. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, CreateManagedEndpointCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, CreateManagedEndpointCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new CreateManagedEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateManagedEndpointCommandInput} for command's `input` shape.
- * @see {@link CreateManagedEndpointCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateManagedEndpointCommand extends $Command<CreateManagedEndpointCommandInput, CreateManagedEndpointCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: CreateManagedEndpointCommandInput;
     constructor(input: CreateManagedEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateManagedEndpointCommandInput, CreateManagedEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateVirtualClusterCommandInput extends CreateVirtualClusterRe
 }
 export interface CreateVirtualClusterCommandOutput extends CreateVirtualClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, CreateVirtualClusterCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, CreateVirtualClusterCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new CreateVirtualClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateVirtualClusterCommandInput} for command's `input` shape.
- * @see {@link CreateVirtualClusterCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateVirtualClusterCommand extends $Command<CreateVirtualClusterCommandInput, CreateVirtualClusterCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: CreateVirtualClusterCommandInput;
     constructor(input: CreateVirtualClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVirtualClusterCommandInput, CreateVirtualClusterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteManagedEndpointCommandInput extends DeleteManagedEndpoint
 }
 export interface DeleteManagedEndpointCommandOutput extends DeleteManagedEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a managed endpoint. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, DeleteManagedEndpointCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, DeleteManagedEndpointCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new DeleteManagedEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteManagedEndpointCommandInput} for command's `input` shape.
- * @see {@link DeleteManagedEndpointCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteManagedEndpointCommand extends $Command<DeleteManagedEndpointCommandInput, DeleteManagedEndpointCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: DeleteManagedEndpointCommandInput;
     constructor(input: DeleteManagedEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteManagedEndpointCommandInput, DeleteManagedEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteVirtualClusterCommandInput extends DeleteVirtualClusterRe
 }
 export interface DeleteVirtualClusterCommandOutput extends DeleteVirtualClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, DeleteVirtualClusterCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, DeleteVirtualClusterCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new DeleteVirtualClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVirtualClusterCommandInput} for command's `input` shape.
- * @see {@link DeleteVirtualClusterCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVirtualClusterCommand extends $Command<DeleteVirtualClusterCommandInput, DeleteVirtualClusterCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: DeleteVirtualClusterCommandInput;
     constructor(input: DeleteVirtualClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVirtualClusterCommandInput, DeleteVirtualClusterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeJobRunCommandInput extends DescribeJobRunRequest {
 }
 export interface DescribeJobRunCommandOutput extends DescribeJobRunResponse, __MetadataBearer {
 }
-/**
- * <p>Displays detailed information about a job run. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, DescribeJobRunCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, DescribeJobRunCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new DescribeJobRunCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeJobRunCommandInput} for command's `input` shape.
- * @see {@link DescribeJobRunCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeJobRunCommand extends $Command<DescribeJobRunCommandInput, DescribeJobRunCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: DescribeJobRunCommandInput;
     constructor(input: DescribeJobRunCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeJobRunCommandInput, DescribeJobRunCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeManagedEndpointCommandInput extends DescribeManagedEndp
 }
 export interface DescribeManagedEndpointCommandOutput extends DescribeManagedEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Displays detailed information about a managed endpoint. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, DescribeManagedEndpointCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, DescribeManagedEndpointCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new DescribeManagedEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeManagedEndpointCommandInput} for command's `input` shape.
- * @see {@link DescribeManagedEndpointCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeManagedEndpointCommand extends $Command<DescribeManagedEndpointCommandInput, DescribeManagedEndpointCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: DescribeManagedEndpointCommandInput;
     constructor(input: DescribeManagedEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeManagedEndpointCommandInput, DescribeManagedEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVirtualClusterCommandInput extends DescribeVirtualClust
 }
 export interface DescribeVirtualClusterCommandOutput extends DescribeVirtualClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Displays detailed information about a specified virtual cluster. Virtual cluster is a managed entity on Amazon EMR on EKS. You can create, describe, list and delete virtual clusters. They do not consume any additional resource in your system. A single virtual cluster maps to a single Kubernetes namespace. Given this relationship, you can model virtual clusters the same way you model Kubernetes namespaces to meet your requirements.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, DescribeVirtualClusterCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, DescribeVirtualClusterCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new DescribeVirtualClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVirtualClusterCommandInput} for command's `input` shape.
- * @see {@link DescribeVirtualClusterCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVirtualClusterCommand extends $Command<DescribeVirtualClusterCommandInput, DescribeVirtualClusterCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: DescribeVirtualClusterCommandInput;
     constructor(input: DescribeVirtualClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVirtualClusterCommandInput, DescribeVirtualClusterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListJobRunsCommandInput extends ListJobRunsRequest {
 }
 export interface ListJobRunsCommandOutput extends ListJobRunsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists job runs based on a set of parameters. A job run is a unit of work, such as a Spark jar, PySpark script, or SparkSQL query, that you submit to Amazon EMR on EKS.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, ListJobRunsCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, ListJobRunsCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new ListJobRunsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListJobRunsCommandInput} for command's `input` shape.
- * @see {@link ListJobRunsCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListJobRunsCommand extends $Command<ListJobRunsCommandInput, ListJobRunsCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: ListJobRunsCommandInput;
     constructor(input: ListJobRunsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListJobRunsCommandInput, ListJobRunsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListManagedEndpointsCommandInput extends ListManagedEndpointsRe
 }
 export interface ListManagedEndpointsCommandOutput extends ListManagedEndpointsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists managed endpoints based on a set of parameters. A managed endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so that EMR Studio can communicate with your virtual cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EMRContainersClient, ListManagedEndpointsCommand } from "@aws-sdk/client-emr-containers"; // ES Modules import
- * // const { EMRContainersClient, ListManagedEndpointsCommand } = require("@aws-sdk/client-emr-containers"); // CommonJS import
- * const client = new EMRContainersClient(config);
- * const command = new ListManagedEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListManagedEndpointsCommandInput} for command's `input` shape.
- * @see {@link ListManagedEndpointsCommandOutput} for command's `response` shape.
- * @see {@link EMRContainersClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListManagedEndpointsCommand extends $Command<ListManagedEndpointsCommandInput, ListManagedEndpointsCommandOutput, EMRContainersClientResolvedConfig> {
     readonly input: ListManagedEndpointsCommandInput;
     constructor(input: ListManagedEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EMRContainersClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListManagedEndpointsCommandInput, ListManagedEndpointsCommandOutput>;
     private serialize;
     private deserialize;