@aws-sdk/client-athena 3.315.0 → 3.316.0

package/dist-types/Athena.d.ts

@@ -60,567 +60,384 @@ import { UpdateNotebookCommandInput, UpdateNotebookCommandOutput } from "./comma
 import { UpdateNotebookMetadataCommandInput, UpdateNotebookMetadataCommandOutput } from "./commands/UpdateNotebookMetadataCommand";
 import { UpdatePreparedStatementCommandInput, UpdatePreparedStatementCommandOutput } from "./commands/UpdatePreparedStatementCommand";
 import { UpdateWorkGroupCommandInput, UpdateWorkGroupCommandOutput } from "./commands/UpdateWorkGroupCommand";
-/**
- * @public
- * <p>Amazon Athena is an interactive query service that lets you use standard SQL
- *             to analyze data directly in Amazon S3. You can point Athena at your
- *             data in Amazon S3 and run ad-hoc queries and get results in seconds. Athena is serverless, so there is no infrastructure to set up or manage. You pay
- *             only for the queries you run. Athena scales automatically—executing queries
- *             in parallel—so results are fast, even with large datasets and complex queries. For more
- *             information, see <a href="http://docs.aws.amazon.com/athena/latest/ug/what-is.html">What is Amazon Athena</a> in the <i>Amazon Athena User
- *                 Guide</i>.</p>
- *          <p>If you connect to Athena using the JDBC driver, use version 1.1.0 of the
- *             driver or later with the Amazon Athena API. Earlier version drivers do not
- *             support the API. For more information and to download the driver, see <a href="https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html">Accessing
- *                     Amazon Athena with JDBC</a>.</p>
- *          <p>For code samples using the Amazon Web Services SDK for Java, see <a href="https://docs.aws.amazon.com/athena/latest/ug/code-samples.html">Examples and
- *                 Code Samples</a> in the <i>Amazon Athena User
- *             Guide</i>.</p>
- */
-export declare class Athena extends AthenaClient {
-    /**
-     * @public
-     * <p>Returns the details of a single named query or a list of up to 50 queries, which you
-     *             provide as an array of query ID strings. Requires you to have access to the workgroup in
-     *             which the queries were saved. Use <a>ListNamedQueriesInput</a> to get the
-     *             list of named query IDs in the specified workgroup. If information could not be
-     *             retrieved for a submitted query ID, information about the query ID submitted is listed
-     *             under <a>UnprocessedNamedQueryId</a>. Named queries differ from executed
-     *             queries. Use <a>BatchGetQueryExecutionInput</a> to get details about each
-     *             unique query execution, and <a>ListQueryExecutionsInput</a> to get a list of
-     *             query execution IDs.</p>
+export interface Athena {
+    /**
+     * @see {@link BatchGetNamedQueryCommand}
      */
     batchGetNamedQuery(args: BatchGetNamedQueryCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetNamedQueryCommandOutput>;
     batchGetNamedQuery(args: BatchGetNamedQueryCommandInput, cb: (err: any, data?: BatchGetNamedQueryCommandOutput) => void): void;
     batchGetNamedQuery(args: BatchGetNamedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetNamedQueryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns the details of a single prepared statement or a list of up to 256 prepared
-     *             statements for the array of prepared statement names that you provide. Requires you to
-     *             have access to the workgroup to which the prepared statements belong. If a prepared
-     *             statement cannot be retrieved for the name specified, the statement is listed in
-     *                 <code>UnprocessedPreparedStatementNames</code>.</p>
+     * @see {@link BatchGetPreparedStatementCommand}
      */
     batchGetPreparedStatement(args: BatchGetPreparedStatementCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetPreparedStatementCommandOutput>;
     batchGetPreparedStatement(args: BatchGetPreparedStatementCommandInput, cb: (err: any, data?: BatchGetPreparedStatementCommandOutput) => void): void;
     batchGetPreparedStatement(args: BatchGetPreparedStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetPreparedStatementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns the details of a single query execution or a list of up to 50 query
-     *             executions, which you provide as an array of query execution ID strings. Requires you to
-     *             have access to the workgroup in which the queries ran. To get a list of query execution
-     *             IDs, use <a>ListQueryExecutionsInput$WorkGroup</a>. Query executions differ
-     *             from named (saved) queries. Use <a>BatchGetNamedQueryInput</a> to get details
-     *             about named queries.</p>
+     * @see {@link BatchGetQueryExecutionCommand}
      */
     batchGetQueryExecution(args: BatchGetQueryExecutionCommandInput, options?: __HttpHandlerOptions): Promise<BatchGetQueryExecutionCommandOutput>;
     batchGetQueryExecution(args: BatchGetQueryExecutionCommandInput, cb: (err: any, data?: BatchGetQueryExecutionCommandOutput) => void): void;
     batchGetQueryExecution(args: BatchGetQueryExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchGetQueryExecutionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates (registers) a data catalog with the specified name and properties. Catalogs
-     *             created are visible to all users of the same Amazon Web Services account.</p>
+     * @see {@link CreateDataCatalogCommand}
      */
     createDataCatalog(args: CreateDataCatalogCommandInput, options?: __HttpHandlerOptions): Promise<CreateDataCatalogCommandOutput>;
     createDataCatalog(args: CreateDataCatalogCommandInput, cb: (err: any, data?: CreateDataCatalogCommandOutput) => void): void;
     createDataCatalog(args: CreateDataCatalogCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDataCatalogCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a named query in the specified workgroup. Requires that you have access to the
-     *             workgroup.</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
-     *                 Code Samples</a> in the <i>Amazon Athena User
-     *             Guide</i>.</p>
+     * @see {@link CreateNamedQueryCommand}
      */
     createNamedQuery(args: CreateNamedQueryCommandInput, options?: __HttpHandlerOptions): Promise<CreateNamedQueryCommandOutput>;
     createNamedQuery(args: CreateNamedQueryCommandInput, cb: (err: any, data?: CreateNamedQueryCommandOutput) => void): void;
     createNamedQuery(args: CreateNamedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateNamedQueryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates an empty <code>ipynb</code> file in the specified Apache Spark enabled
-     *             workgroup. Throws an error if a file in the workgroup with the same name already
-     *             exists.</p>
+     * @see {@link CreateNotebookCommand}
      */
     createNotebook(args: CreateNotebookCommandInput, options?: __HttpHandlerOptions): Promise<CreateNotebookCommandOutput>;
     createNotebook(args: CreateNotebookCommandInput, cb: (err: any, data?: CreateNotebookCommandOutput) => void): void;
     createNotebook(args: CreateNotebookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateNotebookCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a prepared statement for use with SQL queries in Athena.</p>
+     * @see {@link CreatePreparedStatementCommand}
      */
     createPreparedStatement(args: CreatePreparedStatementCommandInput, options?: __HttpHandlerOptions): Promise<CreatePreparedStatementCommandOutput>;
     createPreparedStatement(args: CreatePreparedStatementCommandInput, cb: (err: any, data?: CreatePreparedStatementCommandOutput) => void): void;
     createPreparedStatement(args: CreatePreparedStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreatePreparedStatementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets an authentication token and the URL at which the notebook can be accessed. During
-     *             programmatic access, <code>CreatePresignedNotebookUrl</code> must be called every 10
-     *             minutes to refresh the authentication token. For information about granting programmatic
-     *             access, see <a href="https://docs.aws.amazon.com/athena/latest/ug/setting-up.html#setting-up-grant-programmatic-access">Grant
-     *                 programmatic access</a>.</p>
+     * @see {@link CreatePresignedNotebookUrlCommand}
      */
     createPresignedNotebookUrl(args: CreatePresignedNotebookUrlCommandInput, options?: __HttpHandlerOptions): Promise<CreatePresignedNotebookUrlCommandOutput>;
     createPresignedNotebookUrl(args: CreatePresignedNotebookUrlCommandInput, cb: (err: any, data?: CreatePresignedNotebookUrlCommandOutput) => void): void;
     createPresignedNotebookUrl(args: CreatePresignedNotebookUrlCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreatePresignedNotebookUrlCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a workgroup with the specified name. A workgroup can be an Apache Spark
-     *             enabled workgroup or an Athena SQL workgroup.</p>
+     * @see {@link CreateWorkGroupCommand}
      */
     createWorkGroup(args: CreateWorkGroupCommandInput, options?: __HttpHandlerOptions): Promise<CreateWorkGroupCommandOutput>;
     createWorkGroup(args: CreateWorkGroupCommandInput, cb: (err: any, data?: CreateWorkGroupCommandOutput) => void): void;
     createWorkGroup(args: CreateWorkGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateWorkGroupCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes a data catalog.</p>
+     * @see {@link DeleteDataCatalogCommand}
      */
     deleteDataCatalog(args: DeleteDataCatalogCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDataCatalogCommandOutput>;
     deleteDataCatalog(args: DeleteDataCatalogCommandInput, cb: (err: any, data?: DeleteDataCatalogCommandOutput) => void): void;
     deleteDataCatalog(args: DeleteDataCatalogCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDataCatalogCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the named query if you have access to the workgroup in which the query was
-     *             saved.</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
-     *                 Code Samples</a> in the <i>Amazon Athena User
-     *             Guide</i>.</p>
+     * @see {@link DeleteNamedQueryCommand}
      */
     deleteNamedQuery(args: DeleteNamedQueryCommandInput, options?: __HttpHandlerOptions): Promise<DeleteNamedQueryCommandOutput>;
     deleteNamedQuery(args: DeleteNamedQueryCommandInput, cb: (err: any, data?: DeleteNamedQueryCommandOutput) => void): void;
     deleteNamedQuery(args: DeleteNamedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteNamedQueryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified notebook.</p>
+     * @see {@link DeleteNotebookCommand}
      */
     deleteNotebook(args: DeleteNotebookCommandInput, options?: __HttpHandlerOptions): Promise<DeleteNotebookCommandOutput>;
     deleteNotebook(args: DeleteNotebookCommandInput, cb: (err: any, data?: DeleteNotebookCommandOutput) => void): void;
     deleteNotebook(args: DeleteNotebookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteNotebookCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the prepared statement with the specified name from the specified
-     *             workgroup.</p>
+     * @see {@link DeletePreparedStatementCommand}
      */
     deletePreparedStatement(args: DeletePreparedStatementCommandInput, options?: __HttpHandlerOptions): Promise<DeletePreparedStatementCommandOutput>;
     deletePreparedStatement(args: DeletePreparedStatementCommandInput, cb: (err: any, data?: DeletePreparedStatementCommandOutput) => void): void;
     deletePreparedStatement(args: DeletePreparedStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeletePreparedStatementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the workgroup with the specified name. The primary workgroup cannot be
-     *             deleted.</p>
+     * @see {@link DeleteWorkGroupCommand}
      */
     deleteWorkGroup(args: DeleteWorkGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteWorkGroupCommandOutput>;
     deleteWorkGroup(args: DeleteWorkGroupCommandInput, cb: (err: any, data?: DeleteWorkGroupCommandOutput) => void): void;
     deleteWorkGroup(args: DeleteWorkGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteWorkGroupCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Exports the specified notebook and its metadata.</p>
+     * @see {@link ExportNotebookCommand}
      */
     exportNotebook(args: ExportNotebookCommandInput, options?: __HttpHandlerOptions): Promise<ExportNotebookCommandOutput>;
     exportNotebook(args: ExportNotebookCommandInput, cb: (err: any, data?: ExportNotebookCommandOutput) => void): void;
     exportNotebook(args: ExportNotebookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExportNotebookCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes a previously submitted calculation execution.</p>
+     * @see {@link GetCalculationExecutionCommand}
      */
     getCalculationExecution(args: GetCalculationExecutionCommandInput, options?: __HttpHandlerOptions): Promise<GetCalculationExecutionCommandOutput>;
     getCalculationExecution(args: GetCalculationExecutionCommandInput, cb: (err: any, data?: GetCalculationExecutionCommandOutput) => void): void;
     getCalculationExecution(args: GetCalculationExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCalculationExecutionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the unencrypted code that was executed for the calculation.</p>
+     * @see {@link GetCalculationExecutionCodeCommand}
      */
     getCalculationExecutionCode(args: GetCalculationExecutionCodeCommandInput, options?: __HttpHandlerOptions): Promise<GetCalculationExecutionCodeCommandOutput>;
     getCalculationExecutionCode(args: GetCalculationExecutionCodeCommandInput, cb: (err: any, data?: GetCalculationExecutionCodeCommandOutput) => void): void;
     getCalculationExecutionCode(args: GetCalculationExecutionCodeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCalculationExecutionCodeCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the status of a current calculation.</p>
+     * @see {@link GetCalculationExecutionStatusCommand}
      */
     getCalculationExecutionStatus(args: GetCalculationExecutionStatusCommandInput, options?: __HttpHandlerOptions): Promise<GetCalculationExecutionStatusCommandOutput>;
     getCalculationExecutionStatus(args: GetCalculationExecutionStatusCommandInput, cb: (err: any, data?: GetCalculationExecutionStatusCommandOutput) => void): void;
     getCalculationExecutionStatus(args: GetCalculationExecutionStatusCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetCalculationExecutionStatusCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns a database object for the specified database and data catalog.</p>
+     * @see {@link GetDatabaseCommand}
      */
     getDatabase(args: GetDatabaseCommandInput, options?: __HttpHandlerOptions): Promise<GetDatabaseCommandOutput>;
     getDatabase(args: GetDatabaseCommandInput, cb: (err: any, data?: GetDatabaseCommandOutput) => void): void;
     getDatabase(args: GetDatabaseCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDatabaseCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns the specified data catalog.</p>
+     * @see {@link GetDataCatalogCommand}
      */
     getDataCatalog(args: GetDataCatalogCommandInput, options?: __HttpHandlerOptions): Promise<GetDataCatalogCommandOutput>;
     getDataCatalog(args: GetDataCatalogCommandInput, cb: (err: any, data?: GetDataCatalogCommandOutput) => void): void;
     getDataCatalog(args: GetDataCatalogCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDataCatalogCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns information about a single query. Requires that you have access to the
-     *             workgroup in which the query was saved.</p>
+     * @see {@link GetNamedQueryCommand}
      */
     getNamedQuery(args: GetNamedQueryCommandInput, options?: __HttpHandlerOptions): Promise<GetNamedQueryCommandOutput>;
     getNamedQuery(args: GetNamedQueryCommandInput, cb: (err: any, data?: GetNamedQueryCommandOutput) => void): void;
     getNamedQuery(args: GetNamedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetNamedQueryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves notebook metadata for the specified notebook ID.</p>
+     * @see {@link GetNotebookMetadataCommand}
      */
     getNotebookMetadata(args: GetNotebookMetadataCommandInput, options?: __HttpHandlerOptions): Promise<GetNotebookMetadataCommandOutput>;
     getNotebookMetadata(args: GetNotebookMetadataCommandInput, cb: (err: any, data?: GetNotebookMetadataCommandOutput) => void): void;
     getNotebookMetadata(args: GetNotebookMetadataCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetNotebookMetadataCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Retrieves the prepared statement with the specified name from the specified
-     *             workgroup.</p>
+     * @see {@link GetPreparedStatementCommand}
      */
     getPreparedStatement(args: GetPreparedStatementCommandInput, options?: __HttpHandlerOptions): Promise<GetPreparedStatementCommandOutput>;
     getPreparedStatement(args: GetPreparedStatementCommandInput, cb: (err: any, data?: GetPreparedStatementCommandOutput) => void): void;
     getPreparedStatement(args: GetPreparedStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetPreparedStatementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns information about a single execution of a query if you have access to the
-     *             workgroup in which the query ran. Each time a query executes, information about the
-     *             query execution is saved with a unique ID.</p>
+     * @see {@link GetQueryExecutionCommand}
      */
     getQueryExecution(args: GetQueryExecutionCommandInput, options?: __HttpHandlerOptions): Promise<GetQueryExecutionCommandOutput>;
     getQueryExecution(args: GetQueryExecutionCommandInput, cb: (err: any, data?: GetQueryExecutionCommandOutput) => void): void;
     getQueryExecution(args: GetQueryExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetQueryExecutionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Streams the results of a single query execution specified by
-     *                 <code>QueryExecutionId</code> from the Athena query results location in
-     *                 Amazon S3. For more information, see <a href="https://docs.aws.amazon.com/athena/latest/ug/querying.html">Working with query results, recent queries, and
-     *                 output files</a> in the <i>Amazon Athena User Guide</i>.
-     *             This request does not execute the query but returns results. Use <a>StartQueryExecution</a> to run a query.</p>
-     *          <p>To stream query results successfully, the IAM principal with permission to call
-     *                 <code>GetQueryResults</code> also must have permissions to the Amazon S3
-     *             <code>GetObject</code> action for the Athena query results location.</p>
-     *          <important>
-     *             <p>IAM principals with permission to the Amazon S3
-     *                 <code>GetObject</code> action for the query results location are able to retrieve
-     *                 query results from Amazon S3 even if permission to the
-     *                     <code>GetQueryResults</code> action is denied. To restrict user or role access,
-     *                 ensure that Amazon S3 permissions to the Athena query location
-     *                 are denied.</p>
-     *          </important>
+     * @see {@link GetQueryResultsCommand}
      */
     getQueryResults(args: GetQueryResultsCommandInput, options?: __HttpHandlerOptions): Promise<GetQueryResultsCommandOutput>;
     getQueryResults(args: GetQueryResultsCommandInput, cb: (err: any, data?: GetQueryResultsCommandOutput) => void): void;
     getQueryResults(args: GetQueryResultsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetQueryResultsCommandOutput) => void): void;
     /**
-     * @public
-     * <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. Query execution runtime
-     *             statistics are returned only when <a>QueryExecutionStatus$State</a> is in a
-     *             SUCCEEDED or FAILED state. Stage-level input and output row count and data size
-     *             statistics are not shown when a query has row-level filters defined in Lake
-     *             Formation.</p>
+     * @see {@link GetQueryRuntimeStatisticsCommand}
      */
     getQueryRuntimeStatistics(args: GetQueryRuntimeStatisticsCommandInput, options?: __HttpHandlerOptions): Promise<GetQueryRuntimeStatisticsCommandOutput>;
     getQueryRuntimeStatistics(args: GetQueryRuntimeStatisticsCommandInput, cb: (err: any, data?: GetQueryRuntimeStatisticsCommandOutput) => void): void;
     getQueryRuntimeStatistics(args: GetQueryRuntimeStatisticsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetQueryRuntimeStatisticsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the full details of a previously created session, including the session status
-     *             and configuration.</p>
+     * @see {@link GetSessionCommand}
      */
     getSession(args: GetSessionCommandInput, options?: __HttpHandlerOptions): Promise<GetSessionCommandOutput>;
     getSession(args: GetSessionCommandInput, cb: (err: any, data?: GetSessionCommandOutput) => void): void;
     getSession(args: GetSessionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSessionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets the current status of a session.</p>
+     * @see {@link GetSessionStatusCommand}
      */
     getSessionStatus(args: GetSessionStatusCommandInput, options?: __HttpHandlerOptions): Promise<GetSessionStatusCommandOutput>;
     getSessionStatus(args: GetSessionStatusCommandInput, cb: (err: any, data?: GetSessionStatusCommandOutput) => void): void;
     getSessionStatus(args: GetSessionStatusCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetSessionStatusCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns table metadata for the specified catalog, database, and table.</p>
+     * @see {@link GetTableMetadataCommand}
      */
     getTableMetadata(args: GetTableMetadataCommandInput, options?: __HttpHandlerOptions): Promise<GetTableMetadataCommandOutput>;
     getTableMetadata(args: GetTableMetadataCommandInput, cb: (err: any, data?: GetTableMetadataCommandOutput) => void): void;
     getTableMetadata(args: GetTableMetadataCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetTableMetadataCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns information about the workgroup with the specified name.</p>
+     * @see {@link GetWorkGroupCommand}
      */
     getWorkGroup(args: GetWorkGroupCommandInput, options?: __HttpHandlerOptions): Promise<GetWorkGroupCommandOutput>;
     getWorkGroup(args: GetWorkGroupCommandInput, cb: (err: any, data?: GetWorkGroupCommandOutput) => void): void;
     getWorkGroup(args: GetWorkGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetWorkGroupCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link ImportNotebookCommand}
      */
     importNotebook(args: ImportNotebookCommandInput, options?: __HttpHandlerOptions): Promise<ImportNotebookCommandOutput>;
     importNotebook(args: ImportNotebookCommandInput, cb: (err: any, data?: ImportNotebookCommandOutput) => void): void;
     importNotebook(args: ImportNotebookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ImportNotebookCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns the supported DPU sizes for the supported application runtimes (for example,
-     *                 <code>Athena notebook version 1</code>). </p>
+     * @see {@link ListApplicationDPUSizesCommand}
      */
     listApplicationDPUSizes(args: ListApplicationDPUSizesCommandInput, options?: __HttpHandlerOptions): Promise<ListApplicationDPUSizesCommandOutput>;
     listApplicationDPUSizes(args: ListApplicationDPUSizesCommandInput, cb: (err: any, data?: ListApplicationDPUSizesCommandOutput) => void): void;
     listApplicationDPUSizes(args: ListApplicationDPUSizesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListApplicationDPUSizesCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link ListCalculationExecutionsCommand}
      */
     listCalculationExecutions(args: ListCalculationExecutionsCommandInput, options?: __HttpHandlerOptions): Promise<ListCalculationExecutionsCommandOutput>;
     listCalculationExecutions(args: ListCalculationExecutionsCommandInput, cb: (err: any, data?: ListCalculationExecutionsCommandOutput) => void): void;
     listCalculationExecutions(args: ListCalculationExecutionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListCalculationExecutionsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the databases in the specified data catalog.</p>
+     * @see {@link ListDatabasesCommand}
      */
     listDatabases(args: ListDatabasesCommandInput, options?: __HttpHandlerOptions): Promise<ListDatabasesCommandOutput>;
     listDatabases(args: ListDatabasesCommandInput, cb: (err: any, data?: ListDatabasesCommandOutput) => void): void;
     listDatabases(args: ListDatabasesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDatabasesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the data catalogs in the current Amazon Web Services account.</p>
-     *          <note>
-     *             <p>In the Athena console, data catalogs are listed as "data sources" on
-     *                 the <b>Data sources</b> page under the <b>Data source name</b> column.</p>
-     *          </note>
+     * @see {@link ListDataCatalogsCommand}
      */
     listDataCatalogs(args: ListDataCatalogsCommandInput, options?: __HttpHandlerOptions): Promise<ListDataCatalogsCommandOutput>;
     listDataCatalogs(args: ListDataCatalogsCommandInput, cb: (err: any, data?: ListDataCatalogsCommandOutput) => void): void;
     listDataCatalogs(args: ListDataCatalogsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDataCatalogsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Returns a list of engine versions that are available to choose from, including the
-     *             Auto option.</p>
+     * @see {@link ListEngineVersionsCommand}
      */
     listEngineVersions(args: ListEngineVersionsCommandInput, options?: __HttpHandlerOptions): Promise<ListEngineVersionsCommandOutput>;
     listEngineVersions(args: ListEngineVersionsCommandInput, cb: (err: any, data?: ListEngineVersionsCommandOutput) => void): void;
     listEngineVersions(args: ListEngineVersionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListEngineVersionsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists, in descending order, the executors that joined a session. Newer executors are
-     *             listed first; older executors are listed later. The result can be optionally filtered by
-     *             state.</p>
+     * @see {@link ListExecutorsCommand}
      */
     listExecutors(args: ListExecutorsCommandInput, options?: __HttpHandlerOptions): Promise<ListExecutorsCommandOutput>;
     listExecutors(args: ListExecutorsCommandInput, cb: (err: any, data?: ListExecutorsCommandOutput) => void): void;
     listExecutors(args: ListExecutorsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListExecutorsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Provides a list of available query IDs only for queries saved in the specified
-     *             workgroup. Requires that you have access to the specified workgroup. If a workgroup is
-     *             not specified, lists the saved queries for the primary workgroup.</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
-     *                 Code Samples</a> in the <i>Amazon Athena User
-     *             Guide</i>.</p>
+     * @see {@link ListNamedQueriesCommand}
      */
     listNamedQueries(args: ListNamedQueriesCommandInput, options?: __HttpHandlerOptions): Promise<ListNamedQueriesCommandOutput>;
     listNamedQueries(args: ListNamedQueriesCommandInput, cb: (err: any, data?: ListNamedQueriesCommandOutput) => void): void;
     listNamedQueries(args: ListNamedQueriesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListNamedQueriesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Displays the notebook files for the specified workgroup in paginated format.</p>
+     * @see {@link ListNotebookMetadataCommand}
      */
     listNotebookMetadata(args: ListNotebookMetadataCommandInput, options?: __HttpHandlerOptions): Promise<ListNotebookMetadataCommandOutput>;
     listNotebookMetadata(args: ListNotebookMetadataCommandInput, cb: (err: any, data?: ListNotebookMetadataCommandOutput) => void): void;
     listNotebookMetadata(args: ListNotebookMetadataCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListNotebookMetadataCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link ListNotebookSessionsCommand}
      */
     listNotebookSessions(args: ListNotebookSessionsCommandInput, options?: __HttpHandlerOptions): Promise<ListNotebookSessionsCommandOutput>;
     listNotebookSessions(args: ListNotebookSessionsCommandInput, cb: (err: any, data?: ListNotebookSessionsCommandOutput) => void): void;
     listNotebookSessions(args: ListNotebookSessionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListNotebookSessionsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the prepared statements in the specified workgroup.</p>
+     * @see {@link ListPreparedStatementsCommand}
      */
     listPreparedStatements(args: ListPreparedStatementsCommandInput, options?: __HttpHandlerOptions): Promise<ListPreparedStatementsCommandOutput>;
     listPreparedStatements(args: ListPreparedStatementsCommandInput, cb: (err: any, data?: ListPreparedStatementsCommandOutput) => void): void;
     listPreparedStatements(args: ListPreparedStatementsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListPreparedStatementsCommandOutput) => void): void;
     /**
-     * @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
-     *             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
-     *                 Code Samples</a> in the <i>Amazon Athena User
-     *             Guide</i>.</p>
+     * @see {@link ListQueryExecutionsCommand}
      */
     listQueryExecutions(args: ListQueryExecutionsCommandInput, options?: __HttpHandlerOptions): Promise<ListQueryExecutionsCommandOutput>;
     listQueryExecutions(args: ListQueryExecutionsCommandInput, cb: (err: any, data?: ListQueryExecutionsCommandOutput) => void): void;
     listQueryExecutions(args: ListQueryExecutionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListQueryExecutionsCommandOutput) => void): void;
     /**
-     * @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
-     *             later.</p>
+     * @see {@link ListSessionsCommand}
      */
     listSessions(args: ListSessionsCommandInput, options?: __HttpHandlerOptions): Promise<ListSessionsCommandOutput>;
     listSessions(args: ListSessionsCommandInput, cb: (err: any, data?: ListSessionsCommandOutput) => void): void;
     listSessions(args: ListSessionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSessionsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the metadata for the tables in the specified data catalog database.</p>
+     * @see {@link ListTableMetadataCommand}
      */
     listTableMetadata(args: ListTableMetadataCommandInput, options?: __HttpHandlerOptions): Promise<ListTableMetadataCommandOutput>;
     listTableMetadata(args: ListTableMetadataCommandInput, cb: (err: any, data?: ListTableMetadataCommandOutput) => void): void;
     listTableMetadata(args: ListTableMetadataCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTableMetadataCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists the tags associated with an Athena workgroup or data catalog
-     *             resource.</p>
+     * @see {@link ListTagsForResourceCommand}
      */
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Lists available workgroups for the account.</p>
+     * @see {@link ListWorkGroupsCommand}
      */
     listWorkGroups(args: ListWorkGroupsCommandInput, options?: __HttpHandlerOptions): Promise<ListWorkGroupsCommandOutput>;
     listWorkGroups(args: ListWorkGroupsCommandInput, cb: (err: any, data?: ListWorkGroupsCommandOutput) => void): void;
     listWorkGroups(args: ListWorkGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListWorkGroupsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Submits calculations for execution within a session. You can supply the code to run as
-     *             an inline code block within the request.</p>
+     * @see {@link StartCalculationExecutionCommand}
      */
     startCalculationExecution(args: StartCalculationExecutionCommandInput, options?: __HttpHandlerOptions): Promise<StartCalculationExecutionCommandOutput>;
     startCalculationExecution(args: StartCalculationExecutionCommandInput, cb: (err: any, data?: StartCalculationExecutionCommandOutput) => void): void;
     startCalculationExecution(args: StartCalculationExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartCalculationExecutionCommandOutput) => void): void;
     /**
-     * @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
-     *             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
-     *                 Code Samples</a> in the <i>Amazon Athena User
-     *             Guide</i>.</p>
+     * @see {@link StartQueryExecutionCommand}
      */
     startQueryExecution(args: StartQueryExecutionCommandInput, options?: __HttpHandlerOptions): Promise<StartQueryExecutionCommandOutput>;
     startQueryExecution(args: StartQueryExecutionCommandInput, cb: (err: any, data?: StartQueryExecutionCommandOutput) => void): void;
     startQueryExecution(args: StartQueryExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartQueryExecutionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a session for running calculations within a workgroup. The session is ready
-     *             when it reaches an <code>IDLE</code> state.</p>
+     * @see {@link StartSessionCommand}
      */
     startSession(args: StartSessionCommandInput, options?: __HttpHandlerOptions): Promise<StartSessionCommandOutput>;
     startSession(args: StartSessionCommandInput, cb: (err: any, data?: StartSessionCommandOutput) => void): void;
     startSession(args: StartSessionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartSessionCommandOutput) => void): void;
     /**
-     * @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
-     *             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>
+     * @see {@link StopCalculationExecutionCommand}
      */
     stopCalculationExecution(args: StopCalculationExecutionCommandInput, options?: __HttpHandlerOptions): Promise<StopCalculationExecutionCommandOutput>;
     stopCalculationExecution(args: StopCalculationExecutionCommandInput, cb: (err: any, data?: StopCalculationExecutionCommandOutput) => void): void;
     stopCalculationExecution(args: StopCalculationExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopCalculationExecutionCommandOutput) => void): void;
     /**
-     * @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
-     *                 Code Samples</a> in the <i>Amazon Athena User
-     *             Guide</i>.</p>
+     * @see {@link StopQueryExecutionCommand}
      */
     stopQueryExecution(args: StopQueryExecutionCommandInput, options?: __HttpHandlerOptions): Promise<StopQueryExecutionCommandOutput>;
     stopQueryExecution(args: StopQueryExecutionCommandInput, cb: (err: any, data?: StopQueryExecutionCommandOutput) => void): void;
     stopQueryExecution(args: StopQueryExecutionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopQueryExecutionCommandOutput) => void): void;
     /**
-     * @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
-     *             example, you can use tags to categorize Athena workgroups or data catalogs
-     *             by purpose, owner, or environment. Use a consistent set of tag keys to make it easier to
-     *             search and filter workgroups or data catalogs in your account. For best practices, see
-     *             <a href="https://docs.aws.amazon.com/whitepapers/latest/tagging-best-practices/tagging-best-practices.html">Tagging Best Practices</a>. Tag keys can be from 1 to 128 UTF-8 Unicode
-     *             characters, and tag values can be from 0 to 256 UTF-8 Unicode characters. Tags can use
-     *             letters and numbers representable in UTF-8, and the following characters: + - = . _ : /
-     *             @. Tag keys and values are case-sensitive. Tag keys must be unique per resource. If you
-     *             specify more than one tag, separate them by commas.</p>
+     * @see {@link TagResourceCommand}
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     /**
-     * @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
-     *             the session when <code>TerminateSession</code> is called are forcefully stopped, but may
-     *             display as <code>FAILED</code> instead of <code>STOPPED</code>.</p>
+     * @see {@link TerminateSessionCommand}
      */
     terminateSession(args: TerminateSessionCommandInput, options?: __HttpHandlerOptions): Promise<TerminateSessionCommandOutput>;
     terminateSession(args: TerminateSessionCommandInput, cb: (err: any, data?: TerminateSessionCommandOutput) => void): void;
     terminateSession(args: TerminateSessionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TerminateSessionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Removes one or more tags from a data catalog or workgroup resource.</p>
+     * @see {@link UntagResourceCommand}
      */
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the data catalog that has the specified name.</p>
+     * @see {@link UpdateDataCatalogCommand}
      */
     updateDataCatalog(args: UpdateDataCatalogCommandInput, options?: __HttpHandlerOptions): Promise<UpdateDataCatalogCommandOutput>;
     updateDataCatalog(args: UpdateDataCatalogCommandInput, cb: (err: any, data?: UpdateDataCatalogCommandOutput) => void): void;
     updateDataCatalog(args: UpdateDataCatalogCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateDataCatalogCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates a <a>NamedQuery</a> object. The database or workgroup cannot be
-     *             updated.</p>
+     * @see {@link UpdateNamedQueryCommand}
      */
     updateNamedQuery(args: UpdateNamedQueryCommandInput, options?: __HttpHandlerOptions): Promise<UpdateNamedQueryCommandOutput>;
     updateNamedQuery(args: UpdateNamedQueryCommandInput, cb: (err: any, data?: UpdateNamedQueryCommandOutput) => void): void;
     updateNamedQuery(args: UpdateNamedQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateNamedQueryCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the contents of a Spark notebook.</p>
+     * @see {@link UpdateNotebookCommand}
      */
     updateNotebook(args: UpdateNotebookCommandInput, options?: __HttpHandlerOptions): Promise<UpdateNotebookCommandOutput>;
     updateNotebook(args: UpdateNotebookCommandInput, cb: (err: any, data?: UpdateNotebookCommandOutput) => void): void;
     updateNotebook(args: UpdateNotebookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateNotebookCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the metadata for a notebook.</p>
+     * @see {@link UpdateNotebookMetadataCommand}
      */
     updateNotebookMetadata(args: UpdateNotebookMetadataCommandInput, options?: __HttpHandlerOptions): Promise<UpdateNotebookMetadataCommandOutput>;
     updateNotebookMetadata(args: UpdateNotebookMetadataCommandInput, cb: (err: any, data?: UpdateNotebookMetadataCommandOutput) => void): void;
     updateNotebookMetadata(args: UpdateNotebookMetadataCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateNotebookMetadataCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates a prepared statement.</p>
+     * @see {@link UpdatePreparedStatementCommand}
      */
     updatePreparedStatement(args: UpdatePreparedStatementCommandInput, options?: __HttpHandlerOptions): Promise<UpdatePreparedStatementCommandOutput>;
     updatePreparedStatement(args: UpdatePreparedStatementCommandInput, cb: (err: any, data?: UpdatePreparedStatementCommandOutput) => void): void;
     updatePreparedStatement(args: UpdatePreparedStatementCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdatePreparedStatementCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Updates the workgroup with the specified name. The workgroup's name cannot be changed.
-     *             Only <code>ConfigurationUpdates</code> can be specified.</p>
+     * @see {@link UpdateWorkGroupCommand}
      */
     updateWorkGroup(args: UpdateWorkGroupCommandInput, options?: __HttpHandlerOptions): Promise<UpdateWorkGroupCommandOutput>;
     updateWorkGroup(args: UpdateWorkGroupCommandInput, cb: (err: any, data?: UpdateWorkGroupCommandOutput) => void): void;
     updateWorkGroup(args: UpdateWorkGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateWorkGroupCommandOutput) => void): void;
 }
+/**
+ * @public
+ * <p>Amazon Athena is an interactive query service that lets you use standard SQL
+ *             to analyze data directly in Amazon S3. You can point Athena at your
+ *             data in Amazon S3 and run ad-hoc queries and get results in seconds. Athena is serverless, so there is no infrastructure to set up or manage. You pay
+ *             only for the queries you run. Athena scales automatically—executing queries
+ *             in parallel—so results are fast, even with large datasets and complex queries. For more
+ *             information, see <a href="http://docs.aws.amazon.com/athena/latest/ug/what-is.html">What is Amazon Athena</a> in the <i>Amazon Athena User
+ *                 Guide</i>.</p>
+ *          <p>If you connect to Athena using the JDBC driver, use version 1.1.0 of the
+ *             driver or later with the Amazon Athena API. Earlier version drivers do not
+ *             support the API. For more information and to download the driver, see <a href="https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html">Accessing
+ *                     Amazon Athena with JDBC</a>.</p>
+ *          <p>For code samples using the Amazon Web Services SDK for Java, see <a href="https://docs.aws.amazon.com/athena/latest/ug/code-samples.html">Examples and
+ *                 Code Samples</a> in the <i>Amazon Athena User
+ *             Guide</i>.</p>
+ */
+export declare class Athena extends AthenaClient implements Athena {
+}