@aws-sdk/client-glue 3.35.0 → 3.38.0

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

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

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

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

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

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

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface ListCrawlersCommandInput extends ListCrawlersRequest {
 }
 export interface ListCrawlersCommandOutput extends ListCrawlersResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the names of all crawler resources in this Amazon Web Services account, or the
- *       resources with the specified tag. This operation allows you to see which
- *       resources are available in your account, and their names.</p>
- *
- *          <p>This operation takes the optional <code>Tags</code> field, which you can use as a filter on
- *       the response so that tagged resources can be retrieved as a group. If you choose to use tags
- *       filtering, only resources with the tag are retrieved.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListCrawlersCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListCrawlersCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListCrawlersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListCrawlersCommandInput} for command's `input` shape.
- * @see {@link ListCrawlersCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListCrawlersCommand extends $Command<ListCrawlersCommandInput, ListCrawlersCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListCrawlersCommandInput;
     constructor(input: ListCrawlersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCrawlersCommandInput, ListCrawlersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ListDevEndpointsCommandInput extends ListDevEndpointsRequest {
 }
 export interface ListDevEndpointsCommandOutput extends ListDevEndpointsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the names of all <code>DevEndpoint</code> resources in this Amazon Web Services account, or the
- *       resources with the specified tag. This operation allows you to see which resources are
- *       available in your account, and their names.</p>
- *
- *          <p>This operation takes the optional <code>Tags</code> field, which you can use as a filter on
- *       the response so that tagged resources can be retrieved as a group. If you choose to use tags
- *       filtering, only resources with the tag are retrieved.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListDevEndpointsCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListDevEndpointsCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListDevEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDevEndpointsCommandInput} for command's `input` shape.
- * @see {@link ListDevEndpointsCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDevEndpointsCommand extends $Command<ListDevEndpointsCommandInput, ListDevEndpointsCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListDevEndpointsCommandInput;
     constructor(input: ListDevEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDevEndpointsCommandInput, ListDevEndpointsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ListJobsCommandInput extends ListJobsRequest {
 }
 export interface ListJobsCommandOutput extends ListJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the names of all job resources in this Amazon Web Services account, or the resources with the specified tag. This operation allows you to see which resources are available in your account, and their names.</p>
- *
- * 	        <p>This operation takes the optional <code>Tags</code> field, which you can use as a filter on
- *       the response so that tagged resources can be retrieved as a group. If you choose to use tags
- *       filtering, only resources with the tag are retrieved.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListJobsCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListJobsCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListJobsCommandInput} for command's `input` shape.
- * @see {@link ListJobsCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListJobsCommand extends $Command<ListJobsCommandInput, ListJobsCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListJobsCommandInput;
     constructor(input: ListJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListJobsCommandInput, ListJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ListMLTransformsCommandInput extends ListMLTransformsRequest {
 }
 export interface ListMLTransformsCommandOutput extends ListMLTransformsResponse, __MetadataBearer {
 }
-/**
- * <p> Retrieves a sortable, filterable list of existing Glue machine learning transforms in this Amazon Web Services account,
- *        or the resources with the specified tag. This operation takes the optional <code>Tags</code> field, which you can use as
- *        a filter of the responses so that tagged resources can be retrieved as a group. If you choose to use tag
- *        filtering, only resources with the tags are retrieved.
- *      </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListMLTransformsCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListMLTransformsCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListMLTransformsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListMLTransformsCommandInput} for command's `input` shape.
- * @see {@link ListMLTransformsCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListMLTransformsCommand extends $Command<ListMLTransformsCommandInput, ListMLTransformsCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListMLTransformsCommandInput;
     constructor(input: ListMLTransformsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListMLTransformsCommandInput, ListMLTransformsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListRegistriesCommandInput extends ListRegistriesInput {
 }
 export interface ListRegistriesCommandOutput extends ListRegistriesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of registries that you have created, with minimal registry information. Registries in the <code>Deleting</code> status will not be included in the results. Empty results will be returned if there are no registries available.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListRegistriesCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListRegistriesCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListRegistriesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRegistriesCommandInput} for command's `input` shape.
- * @see {@link ListRegistriesCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListRegistriesCommand extends $Command<ListRegistriesCommandInput, ListRegistriesCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListRegistriesCommandInput;
     constructor(input: ListRegistriesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRegistriesCommandInput, ListRegistriesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListSchemaVersionsCommandInput extends ListSchemaVersionsInput
 }
 export interface ListSchemaVersionsCommandOutput extends ListSchemaVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of schema versions that you have created, with minimal information. Schema versions in Deleted status will not be included in the results. Empty results will be returned if there are no schema versions available.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListSchemaVersionsCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListSchemaVersionsCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListSchemaVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSchemaVersionsCommandInput} for command's `input` shape.
- * @see {@link ListSchemaVersionsCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSchemaVersionsCommand extends $Command<ListSchemaVersionsCommandInput, ListSchemaVersionsCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListSchemaVersionsCommandInput;
     constructor(input: ListSchemaVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSchemaVersionsCommandInput, ListSchemaVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListSchemasCommandInput extends ListSchemasInput {
 }
 export interface ListSchemasCommandOutput extends ListSchemasResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of schemas with minimal details. Schemas in Deleting status will not be included in the results. Empty results will be returned if there are no schemas available.</p>
- *          <p>When the <code>RegistryId</code> is not provided, all the schemas across registries will be part of the API response.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListSchemasCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListSchemasCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListSchemasCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSchemasCommandInput} for command's `input` shape.
- * @see {@link ListSchemasCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSchemasCommand extends $Command<ListSchemasCommandInput, ListSchemasCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListSchemasCommandInput;
     constructor(input: ListSchemasCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSchemasCommandInput, ListSchemasCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ListTriggersCommandInput extends ListTriggersRequest {
 }
 export interface ListTriggersCommandOutput extends ListTriggersResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the names of all trigger resources in this Amazon Web Services account, or the resources with the specified tag. This operation allows you to see which resources are available in your account, and their names.</p>
- *
- *          <p>This operation takes the optional <code>Tags</code> field, which you can use as a filter on
- *       the response so that tagged resources can be retrieved as a group. If you choose to use tags
- *       filtering, only resources with the tag are retrieved.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, ListTriggersCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, ListTriggersCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new ListTriggersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTriggersCommandInput} for command's `input` shape.
- * @see {@link ListTriggersCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTriggersCommand extends $Command<ListTriggersCommandInput, ListTriggersCommandOutput, GlueClientResolvedConfig> {
     readonly input: ListTriggersCommandInput;
     constructor(input: ListTriggersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTriggersCommandInput, ListTriggersCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface PutDataCatalogEncryptionSettingsCommandInput extends PutDataCat
 }
 export interface PutDataCatalogEncryptionSettingsCommandOutput extends PutDataCatalogEncryptionSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>Sets the security configuration for a specified catalog. After the configuration has been
- *       set, the specified encryption is applied to every catalog write thereafter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, PutDataCatalogEncryptionSettingsCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, PutDataCatalogEncryptionSettingsCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new PutDataCatalogEncryptionSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDataCatalogEncryptionSettingsCommandInput} for command's `input` shape.
- * @see {@link PutDataCatalogEncryptionSettingsCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDataCatalogEncryptionSettingsCommand extends $Command<PutDataCatalogEncryptionSettingsCommandInput, PutDataCatalogEncryptionSettingsCommandOutput, GlueClientResolvedConfig> {
     readonly input: PutDataCatalogEncryptionSettingsCommandInput;
     constructor(input: PutDataCatalogEncryptionSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDataCatalogEncryptionSettingsCommandInput, PutDataCatalogEncryptionSettingsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface PutSchemaVersionMetadataCommandInput extends PutSchemaVersionMe
 }
 export interface PutSchemaVersionMetadataCommandOutput extends PutSchemaVersionMetadataResponse, __MetadataBearer {
 }
-/**
- * <p>Puts the metadata key value pair for a specified schema version ID. A maximum of 10 key value pairs will be allowed per schema version. They can be added over one or more calls.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, PutSchemaVersionMetadataCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, PutSchemaVersionMetadataCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new PutSchemaVersionMetadataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutSchemaVersionMetadataCommandInput} for command's `input` shape.
- * @see {@link PutSchemaVersionMetadataCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutSchemaVersionMetadataCommand extends $Command<PutSchemaVersionMetadataCommandInput, PutSchemaVersionMetadataCommandOutput, GlueClientResolvedConfig> {
     readonly input: PutSchemaVersionMetadataCommandInput;
     constructor(input: PutSchemaVersionMetadataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSchemaVersionMetadataCommandInput, PutSchemaVersionMetadataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutWorkflowRunPropertiesCommandInput extends PutWorkflowRunProp
 }
 export interface PutWorkflowRunPropertiesCommandOutput extends PutWorkflowRunPropertiesResponse, __MetadataBearer {
 }
-/**
- * <p>Puts the specified workflow run properties for the given workflow run. If a property already exists for the specified run, then it overrides the value otherwise adds the property to existing properties.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GlueClient, PutWorkflowRunPropertiesCommand } from "@aws-sdk/client-glue"; // ES Modules import
- * // const { GlueClient, PutWorkflowRunPropertiesCommand } = require("@aws-sdk/client-glue"); // CommonJS import
- * const client = new GlueClient(config);
- * const command = new PutWorkflowRunPropertiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutWorkflowRunPropertiesCommandInput} for command's `input` shape.
- * @see {@link PutWorkflowRunPropertiesCommandOutput} for command's `response` shape.
- * @see {@link GlueClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutWorkflowRunPropertiesCommand extends $Command<PutWorkflowRunPropertiesCommandInput, PutWorkflowRunPropertiesCommandOutput, GlueClientResolvedConfig> {
     readonly input: PutWorkflowRunPropertiesCommandInput;
     constructor(input: PutWorkflowRunPropertiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GlueClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutWorkflowRunPropertiesCommandInput, PutWorkflowRunPropertiesCommandOutput>;
     private serialize;
     private deserialize;

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

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