@aws-sdk/client-athena 3.295.0 → 3.297.0

package/dist-types/commands/ListQueryExecutionsCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { ListQueryExecutionsInput, ListQueryExecutionsOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ListQueryExecutionsCommand}.
  */
 export interface ListQueryExecutionsCommandInput extends ListQueryExecutionsInput {
 }
 /**
+ * @public
+ *
  * The output of {@link ListQueryExecutionsCommand}.
  */
 export interface ListQueryExecutionsCommandOutput extends ListQueryExecutionsOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Provides a list of available query execution IDs for the queries in the specified
  *             workgroup. If a workgroup is not specified, returns a list of query execution IDs for
  *             the primary workgroup. Requires you to have access to the workgroup in which the queries
@@ -31,6 +36,8 @@ export interface ListQueryExecutionsCommandOutput extends ListQueryExecutionsOut
  * const response = await client.send(command);
  * ```
  *
+ * @param ListQueryExecutionsCommandInput - {@link ListQueryExecutionsCommandInput}
+ * @returns {@link ListQueryExecutionsCommandOutput}
  * @see {@link ListQueryExecutionsCommandInput} for command's `input` shape.
  * @see {@link ListQueryExecutionsCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -48,11 +55,20 @@ export interface ListQueryExecutionsCommandOutput extends ListQueryExecutionsOut
 export declare class ListQueryExecutionsCommand extends $Command<ListQueryExecutionsCommandInput, ListQueryExecutionsCommandOutput, AthenaClientResolvedConfig> {
     readonly input: ListQueryExecutionsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListQueryExecutionsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQueryExecutionsCommandInput, ListQueryExecutionsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/ListSessionsCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { ListSessionsRequest, ListSessionsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ListSessionsCommand}.
  */
 export interface ListSessionsCommandInput extends ListSessionsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ListSessionsCommand}.
  */
 export interface ListSessionsCommandOutput extends ListSessionsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Lists the sessions in a workgroup that are in an active state like
  *                 <code>CREATING</code>, <code>CREATED</code>, <code>IDLE</code>, or
  *             <code>BUSY</code>. Newer sessions are listed first; older sessions are listed
@@ -28,6 +33,8 @@ export interface ListSessionsCommandOutput extends ListSessionsResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param ListSessionsCommandInput - {@link ListSessionsCommandInput}
+ * @returns {@link ListSessionsCommandOutput}
  * @see {@link ListSessionsCommandInput} for command's `input` shape.
  * @see {@link ListSessionsCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -48,11 +55,20 @@ export interface ListSessionsCommandOutput extends ListSessionsResponse, __Metad
 export declare class ListSessionsCommand extends $Command<ListSessionsCommandInput, ListSessionsCommandOutput, AthenaClientResolvedConfig> {
     readonly input: ListSessionsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListSessionsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSessionsCommandInput, ListSessionsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/ListTableMetadataCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { ListTableMetadataInput, ListTableMetadataOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ListTableMetadataCommand}.
  */
 export interface ListTableMetadataCommandInput extends ListTableMetadataInput {
 }
 /**
+ * @public
+ *
  * The output of {@link ListTableMetadataCommand}.
  */
 export interface ListTableMetadataCommandOutput extends ListTableMetadataOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Lists the metadata for the tables in the specified data catalog database.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface ListTableMetadataCommandOutput extends ListTableMetadataOutput,
  * const response = await client.send(command);
  * ```
  *
+ * @param ListTableMetadataCommandInput - {@link ListTableMetadataCommandInput}
+ * @returns {@link ListTableMetadataCommandOutput}
  * @see {@link ListTableMetadataCommandInput} for command's `input` shape.
  * @see {@link ListTableMetadataCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -50,11 +57,20 @@ export interface ListTableMetadataCommandOutput extends ListTableMetadataOutput,
 export declare class ListTableMetadataCommand extends $Command<ListTableMetadataCommandInput, ListTableMetadataCommandOutput, AthenaClientResolvedConfig> {
     readonly input: ListTableMetadataCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListTableMetadataCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTableMetadataCommandInput, ListTableMetadataCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ListTagsForResourceCommand}.
  */
 export interface ListTagsForResourceCommandInput extends ListTagsForResourceInput {
 }
 /**
+ * @public
+ *
  * The output of {@link ListTagsForResourceCommand}.
  */
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Lists the tags associated with an Athena workgroup or data catalog
  *             resource.</p>
  * @example
@@ -26,6 +31,8 @@ export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOut
  * const response = await client.send(command);
  * ```
  *
+ * @param ListTagsForResourceCommandInput - {@link ListTagsForResourceCommandInput}
+ * @returns {@link ListTagsForResourceCommandOutput}
  * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
  * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -46,11 +53,20 @@ export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOut
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, AthenaClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListTagsForResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/ListWorkGroupsCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { ListWorkGroupsInput, ListWorkGroupsOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ListWorkGroupsCommand}.
  */
 export interface ListWorkGroupsCommandInput extends ListWorkGroupsInput {
 }
 /**
+ * @public
+ *
  * The output of {@link ListWorkGroupsCommand}.
  */
 export interface ListWorkGroupsCommandOutput extends ListWorkGroupsOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Lists available workgroups for the account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface ListWorkGroupsCommandOutput extends ListWorkGroupsOutput, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param ListWorkGroupsCommandInput - {@link ListWorkGroupsCommandInput}
+ * @returns {@link ListWorkGroupsCommandOutput}
  * @see {@link ListWorkGroupsCommandInput} for command's `input` shape.
  * @see {@link ListWorkGroupsCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -42,11 +49,20 @@ export interface ListWorkGroupsCommandOutput extends ListWorkGroupsOutput, __Met
 export declare class ListWorkGroupsCommand extends $Command<ListWorkGroupsCommandInput, ListWorkGroupsCommandOutput, AthenaClientResolvedConfig> {
     readonly input: ListWorkGroupsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ListWorkGroupsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListWorkGroupsCommandInput, ListWorkGroupsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/StartCalculationExecutionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { StartCalculationExecutionRequest, StartCalculationExecutionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartCalculationExecutionCommand}.
  */
 export interface StartCalculationExecutionCommandInput extends StartCalculationExecutionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartCalculationExecutionCommand}.
  */
 export interface StartCalculationExecutionCommandOutput extends StartCalculationExecutionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Submits calculations for execution within a session. You can supply the code to run as
  *             an inline code block within the request or as an Amazon S3 URL.</p>
  * @example
@@ -26,6 +31,8 @@ export interface StartCalculationExecutionCommandOutput extends StartCalculation
  * const response = await client.send(command);
  * ```
  *
+ * @param StartCalculationExecutionCommandInput - {@link StartCalculationExecutionCommandInput}
+ * @returns {@link StartCalculationExecutionCommandOutput}
  * @see {@link StartCalculationExecutionCommandInput} for command's `input` shape.
  * @see {@link StartCalculationExecutionCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -46,11 +53,20 @@ export interface StartCalculationExecutionCommandOutput extends StartCalculation
 export declare class StartCalculationExecutionCommand extends $Command<StartCalculationExecutionCommandInput, StartCalculationExecutionCommandOutput, AthenaClientResolvedConfig> {
     readonly input: StartCalculationExecutionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartCalculationExecutionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartCalculationExecutionCommandInput, StartCalculationExecutionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/StartQueryExecutionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { StartQueryExecutionInput, StartQueryExecutionOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartQueryExecutionCommand}.
  */
 export interface StartQueryExecutionCommandInput extends StartQueryExecutionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link StartQueryExecutionCommand}.
  */
 export interface StartQueryExecutionCommandOutput extends StartQueryExecutionOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Runs the SQL query statements contained in the <code>Query</code>. Requires you to
  *             have access to the workgroup in which the query ran. Running queries against an external
  *             catalog requires <a>GetDataCatalog</a> permission to the catalog. For code
@@ -30,6 +35,8 @@ export interface StartQueryExecutionCommandOutput extends StartQueryExecutionOut
  * const response = await client.send(command);
  * ```
  *
+ * @param StartQueryExecutionCommandInput - {@link StartQueryExecutionCommandInput}
+ * @returns {@link StartQueryExecutionCommandOutput}
  * @see {@link StartQueryExecutionCommandInput} for command's `input` shape.
  * @see {@link StartQueryExecutionCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -50,11 +57,20 @@ export interface StartQueryExecutionCommandOutput extends StartQueryExecutionOut
 export declare class StartQueryExecutionCommand extends $Command<StartQueryExecutionCommandInput, StartQueryExecutionCommandOutput, AthenaClientResolvedConfig> {
     readonly input: StartQueryExecutionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartQueryExecutionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartQueryExecutionCommandInput, StartQueryExecutionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/StartSessionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { StartSessionRequest, StartSessionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StartSessionCommand}.
  */
 export interface StartSessionCommandInput extends StartSessionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartSessionCommand}.
  */
 export interface StartSessionCommandOutput extends StartSessionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a session for running calculations within a workgroup. The session is ready
  *             when it reaches an <code>IDLE</code> state.</p>
  * @example
@@ -26,6 +31,8 @@ export interface StartSessionCommandOutput extends StartSessionResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param StartSessionCommandInput - {@link StartSessionCommandInput}
+ * @returns {@link StartSessionCommandOutput}
  * @see {@link StartSessionCommandInput} for command's `input` shape.
  * @see {@link StartSessionCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -52,11 +59,20 @@ export interface StartSessionCommandOutput extends StartSessionResponse, __Metad
 export declare class StartSessionCommand extends $Command<StartSessionCommandInput, StartSessionCommandOutput, AthenaClientResolvedConfig> {
     readonly input: StartSessionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartSessionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSessionCommandInput, StartSessionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/StopCalculationExecutionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { StopCalculationExecutionRequest, StopCalculationExecutionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StopCalculationExecutionCommand}.
  */
 export interface StopCalculationExecutionCommandInput extends StopCalculationExecutionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StopCalculationExecutionCommand}.
  */
 export interface StopCalculationExecutionCommandOutput extends StopCalculationExecutionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Requests the cancellation of a calculation. A <code>StopCalculationExecution</code>
  *             call on a calculation that is already in a terminal state (for example,
  *                 <code>STOPPED</code>, <code>FAILED</code>, or <code>COMPLETED</code>) succeeds but
@@ -34,6 +39,8 @@ export interface StopCalculationExecutionCommandOutput extends StopCalculationEx
  * const response = await client.send(command);
  * ```
  *
+ * @param StopCalculationExecutionCommandInput - {@link StopCalculationExecutionCommandInput}
+ * @returns {@link StopCalculationExecutionCommandOutput}
  * @see {@link StopCalculationExecutionCommandInput} for command's `input` shape.
  * @see {@link StopCalculationExecutionCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -54,11 +61,20 @@ export interface StopCalculationExecutionCommandOutput extends StopCalculationEx
 export declare class StopCalculationExecutionCommand extends $Command<StopCalculationExecutionCommandInput, StopCalculationExecutionCommandOutput, AthenaClientResolvedConfig> {
     readonly input: StopCalculationExecutionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StopCalculationExecutionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopCalculationExecutionCommandInput, StopCalculationExecutionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/StopQueryExecutionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { StopQueryExecutionInput, StopQueryExecutionOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link StopQueryExecutionCommand}.
  */
 export interface StopQueryExecutionCommandInput extends StopQueryExecutionInput {
 }
 /**
+ * @public
+ *
  * The output of {@link StopQueryExecutionCommand}.
  */
 export interface StopQueryExecutionCommandOutput extends StopQueryExecutionOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Stops a query execution. Requires you to have access to the workgroup in which the
  *             query ran.</p>
  *          <p>For code samples using the Amazon Web Services SDK for Java, see <a href="http://docs.aws.amazon.com/athena/latest/ug/code-samples.html">Examples and
@@ -29,6 +34,8 @@ export interface StopQueryExecutionCommandOutput extends StopQueryExecutionOutpu
  * const response = await client.send(command);
  * ```
  *
+ * @param StopQueryExecutionCommandInput - {@link StopQueryExecutionCommandInput}
+ * @returns {@link StopQueryExecutionCommandOutput}
  * @see {@link StopQueryExecutionCommandInput} for command's `input` shape.
  * @see {@link StopQueryExecutionCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -46,11 +53,20 @@ export interface StopQueryExecutionCommandOutput extends StopQueryExecutionOutpu
 export declare class StopQueryExecutionCommand extends $Command<StopQueryExecutionCommandInput, StopQueryExecutionCommandOutput, AthenaClientResolvedConfig> {
     readonly input: StopQueryExecutionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StopQueryExecutionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopQueryExecutionCommandInput, StopQueryExecutionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { TagResourceInput, TagResourceOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link TagResourceCommand}.
  */
 export interface TagResourceCommandInput extends TagResourceInput {
 }
 /**
+ * @public
+ *
  * The output of {@link TagResourceCommand}.
  */
 export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Adds one or more tags to an Athena resource. A tag is a label that you
  *             assign to a resource. In Athena, a resource can be a workgroup or data
  *             catalog. Each tag consists of a key and an optional value, both of which you define. For
@@ -35,6 +40,8 @@ export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param TagResourceCommandInput - {@link TagResourceCommandInput}
+ * @returns {@link TagResourceCommandOutput}
  * @see {@link TagResourceCommandInput} for command's `input` shape.
  * @see {@link TagResourceCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -55,11 +62,20 @@ export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataB
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, AthenaClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: TagResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

package/dist-types/commands/TerminateSessionCommand.d.ts

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { TerminateSessionRequest, TerminateSessionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link TerminateSessionCommand}.
  */
 export interface TerminateSessionCommandInput extends TerminateSessionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link TerminateSessionCommand}.
  */
 export interface TerminateSessionCommandOutput extends TerminateSessionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Terminates an active session. A <code>TerminateSession</code> call on a session that
  *             is already inactive (for example, in a <code>FAILED</code>, <code>TERMINATED</code> or
  *                 <code>TERMINATING</code> state) succeeds but has no effect. Calculations running in
@@ -29,6 +34,8 @@ export interface TerminateSessionCommandOutput extends TerminateSessionResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param TerminateSessionCommandInput - {@link TerminateSessionCommandInput}
+ * @returns {@link TerminateSessionCommandOutput}
  * @see {@link TerminateSessionCommandInput} for command's `input` shape.
  * @see {@link TerminateSessionCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -49,11 +56,20 @@ export interface TerminateSessionCommandOutput extends TerminateSessionResponse,
 export declare class TerminateSessionCommand extends $Command<TerminateSessionCommandInput, TerminateSessionCommandOutput, AthenaClientResolvedConfig> {
     readonly input: TerminateSessionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: TerminateSessionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateSessionCommandInput, TerminateSessionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
 import { UntagResourceInput, UntagResourceOutput } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link UntagResourceCommand}.
  */
 export interface UntagResourceCommandInput extends UntagResourceInput {
 }
 /**
+ * @public
+ *
  * The output of {@link UntagResourceCommand}.
  */
 export interface UntagResourceCommandOutput extends UntagResourceOutput, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Removes one or more tags from a data catalog or workgroup resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface UntagResourceCommandOutput extends UntagResourceOutput, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param UntagResourceCommandInput - {@link UntagResourceCommandInput}
+ * @returns {@link UntagResourceCommandOutput}
  * @see {@link UntagResourceCommandInput} for command's `input` shape.
  * @see {@link UntagResourceCommandOutput} for command's `response` shape.
  * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
@@ -45,11 +52,20 @@ export interface UntagResourceCommandOutput extends UntagResourceOutput, __Metad
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, AthenaClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: UntagResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }