@aws-sdk/client-athena 3.218.0 → 3.222.0

package/dist-types/commands/StartSessionCommand.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 { StartSessionRequest, StartSessionResponse } from "../models/models_0";
+export interface StartSessionCommandInput extends StartSessionRequest {
+}
+export interface StartSessionCommandOutput extends StartSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a session for running calculations within a workgroup. The session is ready
+ *             when it reaches an <code>IDLE</code> state.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, StartSessionCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, StartSessionCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new StartSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class StartSessionCommand extends $Command<StartSessionCommandInput, StartSessionCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: StartSessionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: StartSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSessionCommandInput, StartSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,46 @@
+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 { StopCalculationExecutionRequest, StopCalculationExecutionResponse } from "../models/models_0";
+export interface StopCalculationExecutionCommandInput extends StopCalculationExecutionRequest {
+}
+export interface StopCalculationExecutionCommandOutput extends StopCalculationExecutionResponse, __MetadataBearer {
+}
+/**
+ * <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
+ *             has no effect.</p>
+ *         <note>
+ *             <p>Cancelling a calculation is done on a best effort basis. If a calculation cannot
+ *                 be cancelled, you can be charged for its completion. If you are concerned about
+ *                 being charged for a calculation that cannot be cancelled, consider terminating the
+ *                 session in which the calculation is running.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, StopCalculationExecutionCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, StopCalculationExecutionCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new StopCalculationExecutionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class StopCalculationExecutionCommand extends $Command<StopCalculationExecutionCommandInput, StopCalculationExecutionCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: StopCalculationExecutionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: StopCalculationExecutionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopCalculationExecutionCommandInput, StopCalculationExecutionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+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 { TerminateSessionRequest, TerminateSessionResponse } from "../models/models_0";
+export interface TerminateSessionCommandInput extends TerminateSessionRequest {
+}
+export interface TerminateSessionCommandOutput extends TerminateSessionResponse, __MetadataBearer {
+}
+/**
+ * <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
+ *             the session when <code>TerminateSession</code> is called are forcefully stopped, but may
+ *             display as <code>FAILED</code> instead of <code>STOPPED</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, TerminateSessionCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, TerminateSessionCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new TerminateSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @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.
+ *
+ */
+export declare class TerminateSessionCommand extends $Command<TerminateSessionCommandInput, TerminateSessionCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: TerminateSessionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: TerminateSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateSessionCommandInput, TerminateSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateNotebookCommand.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 { UpdateNotebookInput, UpdateNotebookOutput } from "../models/models_0";
+export interface UpdateNotebookCommandInput extends UpdateNotebookInput {
+}
+export interface UpdateNotebookCommandOutput extends UpdateNotebookOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the contents of a Spark notebook.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, UpdateNotebookCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, UpdateNotebookCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new UpdateNotebookCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateNotebookCommandInput} for command's `input` shape.
+ * @see {@link UpdateNotebookCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class UpdateNotebookCommand extends $Command<UpdateNotebookCommandInput, UpdateNotebookCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: UpdateNotebookCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateNotebookCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateNotebookCommandInput, UpdateNotebookCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateNotebookMetadataCommand.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 { UpdateNotebookMetadataInput, UpdateNotebookMetadataOutput } from "../models/models_0";
+export interface UpdateNotebookMetadataCommandInput extends UpdateNotebookMetadataInput {
+}
+export interface UpdateNotebookMetadataCommandOutput extends UpdateNotebookMetadataOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the metadata for a notebook.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AthenaClient, UpdateNotebookMetadataCommand } from "@aws-sdk/client-athena"; // ES Modules import
+ * // const { AthenaClient, UpdateNotebookMetadataCommand } = require("@aws-sdk/client-athena"); // CommonJS import
+ * const client = new AthenaClient(config);
+ * const command = new UpdateNotebookMetadataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateNotebookMetadataCommandInput} for command's `input` shape.
+ * @see {@link UpdateNotebookMetadataCommandOutput} for command's `response` shape.
+ * @see {@link AthenaClientResolvedConfig | config} for AthenaClient's `config` shape.
+ *
+ */
+export declare class UpdateNotebookMetadataCommand extends $Command<UpdateNotebookMetadataCommandInput, UpdateNotebookMetadataCommandOutput, AthenaClientResolvedConfig> {
+    readonly input: UpdateNotebookMetadataCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateNotebookMetadataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AthenaClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateNotebookMetadataCommandInput, UpdateNotebookMetadataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -8,8 +8,11 @@ export interface UpdateWorkGroupCommandInput extends UpdateWorkGroupInput {
 export interface UpdateWorkGroupCommandOutput extends UpdateWorkGroupOutput, __MetadataBearer {
 }
 /**
- * <p>Updates the workgroup with the specified name. The workgroup's name cannot be
- *             changed.</p>
+ * <p>Updates the workgroup with the specified name. The workgroup's name cannot be changed.
+ *             Only one of <code>ConfigurationsUpdates</code> or <code>ConfigurationUpdates</code> can
+ *             be specified; <code>ConfigurationsUpdates</code> for a workgroup with multi engine
+ *             support (for example, an Apache Spark enabled workgroup) or
+ *                 <code>ConfigurationUpdates</code> for an Athena SQL workgroup.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -3,35 +3,58 @@ export * from "./BatchGetPreparedStatementCommand";
 export * from "./BatchGetQueryExecutionCommand";
 export * from "./CreateDataCatalogCommand";
 export * from "./CreateNamedQueryCommand";
+export * from "./CreateNotebookCommand";
 export * from "./CreatePreparedStatementCommand";
+export * from "./CreatePresignedNotebookUrlCommand";
 export * from "./CreateWorkGroupCommand";
 export * from "./DeleteDataCatalogCommand";
 export * from "./DeleteNamedQueryCommand";
+export * from "./DeleteNotebookCommand";
 export * from "./DeletePreparedStatementCommand";
 export * from "./DeleteWorkGroupCommand";
+export * from "./ExportNotebookCommand";
+export * from "./GetCalculationExecutionCodeCommand";
+export * from "./GetCalculationExecutionCommand";
+export * from "./GetCalculationExecutionStatusCommand";
 export * from "./GetDataCatalogCommand";
 export * from "./GetDatabaseCommand";
 export * from "./GetNamedQueryCommand";
+export * from "./GetNotebookMetadataCommand";
 export * from "./GetPreparedStatementCommand";
 export * from "./GetQueryExecutionCommand";
 export * from "./GetQueryResultsCommand";
 export * from "./GetQueryRuntimeStatisticsCommand";
+export * from "./GetSessionCommand";
+export * from "./GetSessionStatusCommand";
 export * from "./GetTableMetadataCommand";
 export * from "./GetWorkGroupCommand";
+export * from "./ImportNotebookCommand";
+export * from "./ListApplicationDPUSizesCommand";
+export * from "./ListCalculationExecutionsCommand";
 export * from "./ListDataCatalogsCommand";
 export * from "./ListDatabasesCommand";
 export * from "./ListEngineVersionsCommand";
+export * from "./ListExecutorsCommand";
 export * from "./ListNamedQueriesCommand";
+export * from "./ListNotebookMetadataCommand";
+export * from "./ListNotebookSessionsCommand";
 export * from "./ListPreparedStatementsCommand";
 export * from "./ListQueryExecutionsCommand";
+export * from "./ListSessionsCommand";
 export * from "./ListTableMetadataCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ListWorkGroupsCommand";
+export * from "./StartCalculationExecutionCommand";
 export * from "./StartQueryExecutionCommand";
+export * from "./StartSessionCommand";
+export * from "./StopCalculationExecutionCommand";
 export * from "./StopQueryExecutionCommand";
 export * from "./TagResourceCommand";
+export * from "./TerminateSessionCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateDataCatalogCommand";
 export * from "./UpdateNamedQueryCommand";
+export * from "./UpdateNotebookCommand";
+export * from "./UpdateNotebookMetadataCommand";
 export * from "./UpdatePreparedStatementCommand";
 export * from "./UpdateWorkGroupCommand";