@aws-sdk/client-athena 3.218.0 → 3.221.0

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ExportNotebookInput, ExportNotebookOutput } from "../models/models_0";
+export interface ExportNotebookCommandInput extends ExportNotebookInput {
+}
+export interface ExportNotebookCommandOutput extends ExportNotebookOutput, __MetadataBearer {
+}
+/**
+ * <p>Exports the specified notebook and its metadata.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ExportNotebookCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ExportNotebookCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ExportNotebookCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExportNotebookCommandInput} for command's `input` shape.
+ * @see {@link ExportNotebookCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ExportNotebookCommand extends $Command<ExportNotebookCommandInput, ExportNotebookCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ExportNotebookCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ExportNotebookCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportNotebookCommandInput, ExportNotebookCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { GetCalculationExecutionCodeRequest, GetCalculationExecutionCodeResponse } from "../models/models_0";
+export interface GetCalculationExecutionCodeCommandInput extends GetCalculationExecutionCodeRequest {
+}
+export interface GetCalculationExecutionCodeCommandOutput extends GetCalculationExecutionCodeResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a pre-signed URL to a copy of the code that was executed for the
+ *             calculation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, GetCalculationExecutionCodeCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, GetCalculationExecutionCodeCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new GetCalculationExecutionCodeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCalculationExecutionCodeCommandInput} for command's `input` shape.
+ * @see {@link GetCalculationExecutionCodeCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class GetCalculationExecutionCodeCommand extends $Command<GetCalculationExecutionCodeCommandInput, GetCalculationExecutionCodeCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: GetCalculationExecutionCodeCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetCalculationExecutionCodeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCalculationExecutionCodeCommandInput, GetCalculationExecutionCodeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { GetCalculationExecutionRequest, GetCalculationExecutionResponse } from "../models/models_0";
+export interface GetCalculationExecutionCommandInput extends GetCalculationExecutionRequest {
+}
+export interface GetCalculationExecutionCommandOutput extends GetCalculationExecutionResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes a previously submitted calculation execution.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, GetCalculationExecutionCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, GetCalculationExecutionCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new GetCalculationExecutionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCalculationExecutionCommandInput} for command's `input` shape.
+ * @see {@link GetCalculationExecutionCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class GetCalculationExecutionCommand extends $Command<GetCalculationExecutionCommandInput, GetCalculationExecutionCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: GetCalculationExecutionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetCalculationExecutionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCalculationExecutionCommandInput, GetCalculationExecutionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { GetCalculationExecutionStatusRequest, GetCalculationExecutionStatusResponse } from "../models/models_0";
+export interface GetCalculationExecutionStatusCommandInput extends GetCalculationExecutionStatusRequest {
+}
+export interface GetCalculationExecutionStatusCommandOutput extends GetCalculationExecutionStatusResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the status of a current calculation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, GetCalculationExecutionStatusCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, GetCalculationExecutionStatusCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new GetCalculationExecutionStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCalculationExecutionStatusCommandInput} for command's `input` shape.
+ * @see {@link GetCalculationExecutionStatusCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class GetCalculationExecutionStatusCommand extends $Command<GetCalculationExecutionStatusCommandInput, GetCalculationExecutionStatusCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: GetCalculationExecutionStatusCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetCalculationExecutionStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCalculationExecutionStatusCommandInput, GetCalculationExecutionStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { GetNotebookMetadataInput, GetNotebookMetadataOutput } from "../models/models_0";
+export interface GetNotebookMetadataCommandInput extends GetNotebookMetadataInput {
+}
+export interface GetNotebookMetadataCommandOutput extends GetNotebookMetadataOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves notebook metadata for the specified notebook ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, GetNotebookMetadataCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, GetNotebookMetadataCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new GetNotebookMetadataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetNotebookMetadataCommandInput} for command's `input` shape.
+ * @see {@link GetNotebookMetadataCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class GetNotebookMetadataCommand extends $Command<GetNotebookMetadataCommandInput, GetNotebookMetadataCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: GetNotebookMetadataCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetNotebookMetadataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetNotebookMetadataCommandInput, GetNotebookMetadataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -8,10 +8,10 @@ export interface GetQueryRuntimeStatisticsCommandInput extends GetQueryRuntimeSt
 export interface GetQueryRuntimeStatisticsCommandOutput extends GetQueryRuntimeStatisticsOutput, __MetadataBearer {
 }
 /**
- * <p>Returns query execution runtime statistics related to a single execution of a query if you
- *             have access to the workgroup in which the query ran. The query execution runtime statistics
- *             is returned only when <a>QueryExecutionStatus$State</a> is in a SUCCEEDED
- *             or FAILED state.</p>
+ * <p>Returns query execution runtime statistics related to a single execution of a query if
+ *             you have access to the workgroup in which the query ran. The query execution runtime
+ *             statistics is returned only when <a>QueryExecutionStatus$State</a> is in a
+ *             SUCCEEDED or FAILED state.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { GetSessionRequest, GetSessionResponse } from "../models/models_0";
+export interface GetSessionCommandInput extends GetSessionRequest {
+}
+export interface GetSessionCommandOutput extends GetSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the full details of a previously created session, including the session status
+ *             and configuration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, GetSessionCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, GetSessionCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new GetSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSessionCommandInput} for command's `input` shape.
+ * @see {@link GetSessionCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class GetSessionCommand extends $Command<GetSessionCommandInput, GetSessionCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: GetSessionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSessionCommandInput, GetSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { GetSessionStatusRequest, GetSessionStatusResponse } from "../models/models_0";
+export interface GetSessionStatusCommandInput extends GetSessionStatusRequest {
+}
+export interface GetSessionStatusCommandOutput extends GetSessionStatusResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the current status of a session.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, GetSessionStatusCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, GetSessionStatusCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new GetSessionStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSessionStatusCommandInput} for command's `input` shape.
+ * @see {@link GetSessionStatusCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class GetSessionStatusCommand extends $Command<GetSessionStatusCommandInput, GetSessionStatusCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: GetSessionStatusCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSessionStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSessionStatusCommandInput, GetSessionStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ImportNotebookInput, ImportNotebookOutput } from "../models/models_0";
+export interface ImportNotebookCommandInput extends ImportNotebookInput {
+}
+export interface ImportNotebookCommandOutput extends ImportNotebookOutput, __MetadataBearer {
+}
+/**
+ * <p>Imports a single <code>ipynb</code> file to a Spark enabled workgroup. The maximum
+ *             file size that can be imported is 10 megabytes. If an <code>ipynb</code> file with the
+ *             same name already exists in the workgroup, throws an error.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ImportNotebookCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ImportNotebookCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ImportNotebookCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportNotebookCommandInput} for command's `input` shape.
+ * @see {@link ImportNotebookCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ImportNotebookCommand extends $Command<ImportNotebookCommandInput, ImportNotebookCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ImportNotebookCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ImportNotebookCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportNotebookCommandInput, ImportNotebookCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ListApplicationDPUSizesInput, ListApplicationDPUSizesOutput } from "../models/models_0";
+export interface ListApplicationDPUSizesCommandInput extends ListApplicationDPUSizesInput {
+}
+export interface ListApplicationDPUSizesCommandOutput extends ListApplicationDPUSizesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the supported DPU sizes for the supported application runtimes (for example,
+ *                 <code>Jupyter 1.0</code>). </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ListApplicationDPUSizesCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ListApplicationDPUSizesCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ListApplicationDPUSizesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListApplicationDPUSizesCommandInput} for command's `input` shape.
+ * @see {@link ListApplicationDPUSizesCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ListApplicationDPUSizesCommand extends $Command<ListApplicationDPUSizesCommandInput, ListApplicationDPUSizesCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ListApplicationDPUSizesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListApplicationDPUSizesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListApplicationDPUSizesCommandInput, ListApplicationDPUSizesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ListCalculationExecutionsRequest, ListCalculationExecutionsResponse } from "../models/models_0";
+export interface ListCalculationExecutionsCommandInput extends ListCalculationExecutionsRequest {
+}
+export interface ListCalculationExecutionsCommandOutput extends ListCalculationExecutionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the calculations that have been submitted to a session in descending order.
+ *             Newer calculations are listed first; older calculations are listed later.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ListCalculationExecutionsCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ListCalculationExecutionsCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ListCalculationExecutionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCalculationExecutionsCommandInput} for command's `input` shape.
+ * @see {@link ListCalculationExecutionsCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ListCalculationExecutionsCommand extends $Command<ListCalculationExecutionsCommandInput, ListCalculationExecutionsCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ListCalculationExecutionsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListCalculationExecutionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCalculationExecutionsCommandInput, ListCalculationExecutionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ListExecutorsRequest, ListExecutorsResponse } from "../models/models_0";
+export interface ListExecutorsCommandInput extends ListExecutorsRequest {
+}
+export interface ListExecutorsCommandOutput extends ListExecutorsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists, in descending order, the executors that have been submitted to a session. Newer
+ *             executors are listed first; older executors are listed later. The result can be
+ *             optionally filtered by state.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ListExecutorsCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ListExecutorsCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ListExecutorsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListExecutorsCommandInput} for command's `input` shape.
+ * @see {@link ListExecutorsCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ListExecutorsCommand extends $Command<ListExecutorsCommandInput, ListExecutorsCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ListExecutorsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListExecutorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListExecutorsCommandInput, ListExecutorsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ListNotebookMetadataInput, ListNotebookMetadataOutput } from "../models/models_0";
+export interface ListNotebookMetadataCommandInput extends ListNotebookMetadataInput {
+}
+export interface ListNotebookMetadataCommandOutput extends ListNotebookMetadataOutput, __MetadataBearer {
+}
+/**
+ * <p>Displays the notebook files for the specified workgroup in paginated format.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ListNotebookMetadataCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ListNotebookMetadataCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ListNotebookMetadataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListNotebookMetadataCommandInput} for command's `input` shape.
+ * @see {@link ListNotebookMetadataCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ListNotebookMetadataCommand extends $Command<ListNotebookMetadataCommandInput, ListNotebookMetadataCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ListNotebookMetadataCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListNotebookMetadataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNotebookMetadataCommandInput, ListNotebookMetadataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ListNotebookSessionsRequest, ListNotebookSessionsResponse } from "../models/models_0";
+export interface ListNotebookSessionsCommandInput extends ListNotebookSessionsRequest {
+}
+export interface ListNotebookSessionsCommandOutput extends ListNotebookSessionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists, in descending order, the sessions that have been created in a notebook 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
+ *             later.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ListNotebookSessionsCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ListNotebookSessionsCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ListNotebookSessionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListNotebookSessionsCommandInput} for command's `input` shape.
+ * @see {@link ListNotebookSessionsCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class ListNotebookSessionsCommand extends $Command<ListNotebookSessionsCommandInput, ListNotebookSessionsCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ListNotebookSessionsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListNotebookSessionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNotebookSessionsCommandInput, ListNotebookSessionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { ListSessionsRequest, ListSessionsResponse } from "../models/models_0";
+export interface ListSessionsCommandInput extends ListSessionsRequest {
+}
+export interface ListSessionsCommandOutput extends ListSessionsResponse, __MetadataBearer {
+}
+/**
+ * <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
+ *             later.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, ListSessionsCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, ListSessionsCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new ListSessionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class ListSessionsCommand extends $Command<ListSessionsCommandInput, ListSessionsCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: ListSessionsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSessionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSessionsCommandInput, ListSessionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AthenaClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AthenaClient";
+import { StartCalculationExecutionRequest, StartCalculationExecutionResponse } from "../models/models_0";
+export interface StartCalculationExecutionCommandInput extends StartCalculationExecutionRequest {
+}
+export interface StartCalculationExecutionCommandOutput extends StartCalculationExecutionResponse, __MetadataBearer {
+}
+/**
+ * <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
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, StartCalculationExecutionCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, StartCalculationExecutionCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new StartCalculationExecutionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class StartCalculationExecutionCommand extends $Command<StartCalculationExecutionCommandInput, StartCalculationExecutionCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: StartCalculationExecutionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: StartCalculationExecutionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartCalculationExecutionCommandInput, StartCalculationExecutionCommandOutput>;
+    private serialize;
+    private deserialize;
+}