@aws-sdk/client-glue 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface StopTriggerCommandInput extends StopTriggerRequest {
 }
 export interface StopTriggerCommandOutput extends StopTriggerResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a specified trigger.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, StopTriggerCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, StopTriggerCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new StopTriggerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopTriggerCommandInput} for command's `input` shape.
- * @see {@link StopTriggerCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopTriggerCommand extends $Command<StopTriggerCommandInput, StopTriggerCommandOutput, GlueClientResolvedConfig> {
     readonly input: StopTriggerCommandInput;
     constructor(input: StopTriggerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopTriggerCommandInput, StopTriggerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface StopWorkflowRunCommandInput extends StopWorkflowRunRequest {
 }
 export interface StopWorkflowRunCommandOutput extends StopWorkflowRunResponse, __MetadataBearer {
 }
-/**
- * <p>Stops the execution of the specified workflow run.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, StopWorkflowRunCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, StopWorkflowRunCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new StopWorkflowRunCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopWorkflowRunCommandInput} for command's `input` shape.
- * @see {@link StopWorkflowRunCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopWorkflowRunCommand extends $Command<StopWorkflowRunCommandInput, StopWorkflowRunCommandOutput, GlueClientResolvedConfig> {
     readonly input: StopWorkflowRunCommandInput;
     constructor(input: StopWorkflowRunCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopWorkflowRunCommandInput, StopWorkflowRunCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Adds tags to a resource. A tag is a label you can assign to an Amazon Web Services resource.
- *       In Glue, you can tag only certain resources. For information about what
- *       resources you can tag, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, TagResourceCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, TagResourceCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, GlueClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Removes tags from a resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UntagResourceCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UntagResourceCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, GlueClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateBlueprintCommandInput extends UpdateBlueprintRequest {
 }
 export interface UpdateBlueprintCommandOutput extends UpdateBlueprintResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a registered blueprint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateBlueprintCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateBlueprintCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateBlueprintCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBlueprintCommandInput} for command's `input` shape.
- * @see {@link UpdateBlueprintCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateBlueprintCommand extends $Command<UpdateBlueprintCommandInput, UpdateBlueprintCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateBlueprintCommandInput;
     constructor(input: UpdateBlueprintCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBlueprintCommandInput, UpdateBlueprintCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateClassifierCommandInput extends UpdateClassifierRequest {
 }
 export interface UpdateClassifierCommandOutput extends UpdateClassifierResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies an existing classifier (a <code>GrokClassifier</code>,
- *       an <code>XMLClassifier</code>, a <code>JsonClassifier</code>, or a <code>CsvClassifier</code>, depending on
- *       which field is present).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateClassifierCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateClassifierCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateClassifierCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateClassifierCommandInput} for command's `input` shape.
- * @see {@link UpdateClassifierCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateClassifierCommand extends $Command<UpdateClassifierCommandInput, UpdateClassifierCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateClassifierCommandInput;
     constructor(input: UpdateClassifierCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateClassifierCommandInput, UpdateClassifierCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateColumnStatisticsForPartitionCommandInput extends UpdateCo
 }
 export interface UpdateColumnStatisticsForPartitionCommandOutput extends UpdateColumnStatisticsForPartitionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates or updates partition statistics of columns.</p>
- *
- *          <p>The Identity and Access Management (IAM) permission required for this operation is <code>UpdatePartition</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateColumnStatisticsForPartitionCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateColumnStatisticsForPartitionCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateColumnStatisticsForPartitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateColumnStatisticsForPartitionCommandInput} for command's `input` shape.
- * @see {@link UpdateColumnStatisticsForPartitionCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateColumnStatisticsForPartitionCommand extends $Command<UpdateColumnStatisticsForPartitionCommandInput, UpdateColumnStatisticsForPartitionCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateColumnStatisticsForPartitionCommandInput;
     constructor(input: UpdateColumnStatisticsForPartitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateColumnStatisticsForPartitionCommandInput, UpdateColumnStatisticsForPartitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateColumnStatisticsForTableCommandInput extends UpdateColumn
 }
 export interface UpdateColumnStatisticsForTableCommandOutput extends UpdateColumnStatisticsForTableResponse, __MetadataBearer {
 }
-/**
- * <p>Creates or updates table statistics of columns.</p>
- *
- * 	        <p>The Identity and Access Management (IAM) permission required for this operation is <code>UpdateTable</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateColumnStatisticsForTableCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateColumnStatisticsForTableCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateColumnStatisticsForTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateColumnStatisticsForTableCommandInput} for command's `input` shape.
- * @see {@link UpdateColumnStatisticsForTableCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateColumnStatisticsForTableCommand extends $Command<UpdateColumnStatisticsForTableCommandInput, UpdateColumnStatisticsForTableCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateColumnStatisticsForTableCommandInput;
     constructor(input: UpdateColumnStatisticsForTableCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateColumnStatisticsForTableCommandInput, UpdateColumnStatisticsForTableCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateConnectionCommandInput extends UpdateConnectionRequest {
 }
 export interface UpdateConnectionCommandOutput extends UpdateConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a connection definition in the Data Catalog.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateConnectionCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateConnectionCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConnectionCommandInput} for command's `input` shape.
- * @see {@link UpdateConnectionCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConnectionCommand extends $Command<UpdateConnectionCommandInput, UpdateConnectionCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateConnectionCommandInput;
     constructor(input: UpdateConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectionCommandInput, UpdateConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateCrawlerCommandInput extends UpdateCrawlerRequest {
 }
 export interface UpdateCrawlerCommandOutput extends UpdateCrawlerResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a crawler. If a crawler is
- *       running, you must stop it using <code>StopCrawler</code> before updating
- *       it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateCrawlerCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateCrawlerCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateCrawlerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCrawlerCommandInput} for command's `input` shape.
- * @see {@link UpdateCrawlerCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCrawlerCommand extends $Command<UpdateCrawlerCommandInput, UpdateCrawlerCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateCrawlerCommandInput;
     constructor(input: UpdateCrawlerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCrawlerCommandInput, UpdateCrawlerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateCrawlerScheduleCommandInput extends UpdateCrawlerSchedule
 }
 export interface UpdateCrawlerScheduleCommandOutput extends UpdateCrawlerScheduleResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the schedule of a crawler using a <code>cron</code> expression. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateCrawlerScheduleCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateCrawlerScheduleCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateCrawlerScheduleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCrawlerScheduleCommandInput} for command's `input` shape.
- * @see {@link UpdateCrawlerScheduleCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCrawlerScheduleCommand extends $Command<UpdateCrawlerScheduleCommandInput, UpdateCrawlerScheduleCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateCrawlerScheduleCommandInput;
     constructor(input: UpdateCrawlerScheduleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCrawlerScheduleCommandInput, UpdateCrawlerScheduleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateDatabaseCommandInput extends UpdateDatabaseRequest {
 }
 export interface UpdateDatabaseCommandOutput extends UpdateDatabaseResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an existing database definition in a Data Catalog.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateDatabaseCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateDatabaseCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateDatabaseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDatabaseCommandInput} for command's `input` shape.
- * @see {@link UpdateDatabaseCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDatabaseCommand extends $Command<UpdateDatabaseCommandInput, UpdateDatabaseCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateDatabaseCommandInput;
     constructor(input: UpdateDatabaseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDatabaseCommandInput, UpdateDatabaseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateDevEndpointCommandInput extends UpdateDevEndpointRequest
 }
 export interface UpdateDevEndpointCommandOutput extends UpdateDevEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a specified development endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateDevEndpointCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateDevEndpointCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateDevEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDevEndpointCommandInput} for command's `input` shape.
- * @see {@link UpdateDevEndpointCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDevEndpointCommand extends $Command<UpdateDevEndpointCommandInput, UpdateDevEndpointCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateDevEndpointCommandInput;
     constructor(input: UpdateDevEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDevEndpointCommandInput, UpdateDevEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateJobCommandInput extends UpdateJobRequest {
 }
 export interface UpdateJobCommandOutput extends UpdateJobResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an existing job definition.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateJobCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateJobCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateJobCommandInput} for command's `input` shape.
- * @see {@link UpdateJobCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateJobCommand extends $Command<UpdateJobCommandInput, UpdateJobCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateJobCommandInput;
     constructor(input: UpdateJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateJobCommandInput, UpdateJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface UpdateMLTransformCommandInput extends UpdateMLTransformRequest
 }
 export interface UpdateMLTransformCommandOutput extends UpdateMLTransformResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an existing machine learning transform. Call this operation to tune the algorithm parameters to achieve better results.</p>
- *
- *          <p>After calling this operation, you can call the <code>StartMLEvaluationTaskRun</code>
- *       operation to assess how well your new parameters achieved your goals (such as improving the
- *       quality of your machine learning transform, or making it more cost-effective).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateMLTransformCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateMLTransformCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateMLTransformCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateMLTransformCommandInput} for command's `input` shape.
- * @see {@link UpdateMLTransformCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateMLTransformCommand extends $Command<UpdateMLTransformCommandInput, UpdateMLTransformCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateMLTransformCommandInput;
     constructor(input: UpdateMLTransformCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateMLTransformCommandInput, UpdateMLTransformCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdatePartitionCommandInput extends UpdatePartitionRequest {
 }
 export interface UpdatePartitionCommandOutput extends UpdatePartitionResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a partition.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdatePartitionCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdatePartitionCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdatePartitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdatePartitionCommandInput} for command's `input` shape.
- * @see {@link UpdatePartitionCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdatePartitionCommand extends $Command<UpdatePartitionCommandInput, UpdatePartitionCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdatePartitionCommandInput;
     constructor(input: UpdatePartitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePartitionCommandInput, UpdatePartitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateRegistryCommandInput extends UpdateRegistryInput {
 }
 export interface UpdateRegistryCommandOutput extends UpdateRegistryResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an existing registry which is used to hold a collection of schemas. The updated properties relate to the registry, and do not modify any of the schemas within the registry. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateRegistryCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateRegistryCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateRegistryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateRegistryCommandInput} for command's `input` shape.
- * @see {@link UpdateRegistryCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateRegistryCommand extends $Command<UpdateRegistryCommandInput, UpdateRegistryCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateRegistryCommandInput;
     constructor(input: UpdateRegistryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRegistryCommandInput, UpdateRegistryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateSchemaCommandInput extends UpdateSchemaInput {
 }
 export interface UpdateSchemaCommandOutput extends UpdateSchemaResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the description, compatibility setting, or version checkpoint for a schema set.</p>
- * 	        <p>For updating the compatibility setting, the call will not validate compatibility for the entire set of schema versions with the new compatibility setting. If the value for <code>Compatibility</code> is provided, the <code>VersionNumber</code> (a checkpoint) is also required. The API will validate the checkpoint version number for consistency.</p>
- *          <p>If the value for the <code>VersionNumber</code> (checkpoint) is provided, <code>Compatibility</code> is optional and this can be used to set/reset a checkpoint for the schema.</p>
- * 	        <p>This update will happen only if the schema is in the AVAILABLE state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateSchemaCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateSchemaCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateSchemaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateSchemaCommandInput} for command's `input` shape.
- * @see {@link UpdateSchemaCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateSchemaCommand extends $Command<UpdateSchemaCommandInput, UpdateSchemaCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateSchemaCommandInput;
     constructor(input: UpdateSchemaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSchemaCommandInput, UpdateSchemaCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateTableCommandInput extends UpdateTableRequest {
 }
 export interface UpdateTableCommandOutput extends UpdateTableResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a metadata table in the Data Catalog.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, UpdateTableCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, UpdateTableCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new UpdateTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateTableCommandInput} for command's `input` shape.
- * @see {@link UpdateTableCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateTableCommand extends $Command<UpdateTableCommandInput, UpdateTableCommandOutput, GlueClientResolvedConfig> {
     readonly input: UpdateTableCommandInput;
     constructor(input: UpdateTableCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTableCommandInput, UpdateTableCommandOutput>;
     private serialize;
     private deserialize;