@aws-sdk/client-athena 3.309.0 → 3.312.0

package/dist-cjs/protocols/Aws_json1_1.js

@@ -9,600 +9,420 @@ const uuid_1 = require("uuid");
 const AthenaServiceException_1 = require("../models/AthenaServiceException");
 const models_0_1 = require("../models/models_0");
 const se_BatchGetNamedQueryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.BatchGetNamedQuery",
-    };
+    const headers = sharedHeaders("BatchGetNamedQuery");
     let body;
     body = JSON.stringify(se_BatchGetNamedQueryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetNamedQueryCommand = se_BatchGetNamedQueryCommand;
 const se_BatchGetPreparedStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.BatchGetPreparedStatement",
-    };
+    const headers = sharedHeaders("BatchGetPreparedStatement");
     let body;
     body = JSON.stringify(se_BatchGetPreparedStatementInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetPreparedStatementCommand = se_BatchGetPreparedStatementCommand;
 const se_BatchGetQueryExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.BatchGetQueryExecution",
-    };
+    const headers = sharedHeaders("BatchGetQueryExecution");
     let body;
     body = JSON.stringify(se_BatchGetQueryExecutionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetQueryExecutionCommand = se_BatchGetQueryExecutionCommand;
 const se_CreateDataCatalogCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.CreateDataCatalog",
-    };
+    const headers = sharedHeaders("CreateDataCatalog");
     let body;
     body = JSON.stringify(se_CreateDataCatalogInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDataCatalogCommand = se_CreateDataCatalogCommand;
 const se_CreateNamedQueryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.CreateNamedQuery",
-    };
+    const headers = sharedHeaders("CreateNamedQuery");
     let body;
     body = JSON.stringify(se_CreateNamedQueryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateNamedQueryCommand = se_CreateNamedQueryCommand;
 const se_CreateNotebookCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.CreateNotebook",
-    };
+    const headers = sharedHeaders("CreateNotebook");
     let body;
     body = JSON.stringify(se_CreateNotebookInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateNotebookCommand = se_CreateNotebookCommand;
 const se_CreatePreparedStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.CreatePreparedStatement",
-    };
+    const headers = sharedHeaders("CreatePreparedStatement");
     let body;
     body = JSON.stringify(se_CreatePreparedStatementInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePreparedStatementCommand = se_CreatePreparedStatementCommand;
 const se_CreatePresignedNotebookUrlCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.CreatePresignedNotebookUrl",
-    };
+    const headers = sharedHeaders("CreatePresignedNotebookUrl");
     let body;
     body = JSON.stringify(se_CreatePresignedNotebookUrlRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePresignedNotebookUrlCommand = se_CreatePresignedNotebookUrlCommand;
 const se_CreateWorkGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.CreateWorkGroup",
-    };
+    const headers = sharedHeaders("CreateWorkGroup");
     let body;
     body = JSON.stringify(se_CreateWorkGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateWorkGroupCommand = se_CreateWorkGroupCommand;
 const se_DeleteDataCatalogCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.DeleteDataCatalog",
-    };
+    const headers = sharedHeaders("DeleteDataCatalog");
     let body;
     body = JSON.stringify(se_DeleteDataCatalogInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDataCatalogCommand = se_DeleteDataCatalogCommand;
 const se_DeleteNamedQueryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.DeleteNamedQuery",
-    };
+    const headers = sharedHeaders("DeleteNamedQuery");
     let body;
     body = JSON.stringify(se_DeleteNamedQueryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteNamedQueryCommand = se_DeleteNamedQueryCommand;
 const se_DeleteNotebookCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.DeleteNotebook",
-    };
+    const headers = sharedHeaders("DeleteNotebook");
     let body;
     body = JSON.stringify(se_DeleteNotebookInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteNotebookCommand = se_DeleteNotebookCommand;
 const se_DeletePreparedStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.DeletePreparedStatement",
-    };
+    const headers = sharedHeaders("DeletePreparedStatement");
     let body;
     body = JSON.stringify(se_DeletePreparedStatementInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeletePreparedStatementCommand = se_DeletePreparedStatementCommand;
 const se_DeleteWorkGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.DeleteWorkGroup",
-    };
+    const headers = sharedHeaders("DeleteWorkGroup");
     let body;
     body = JSON.stringify(se_DeleteWorkGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteWorkGroupCommand = se_DeleteWorkGroupCommand;
 const se_ExportNotebookCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ExportNotebook",
-    };
+    const headers = sharedHeaders("ExportNotebook");
     let body;
     body = JSON.stringify(se_ExportNotebookInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ExportNotebookCommand = se_ExportNotebookCommand;
 const se_GetCalculationExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetCalculationExecution",
-    };
+    const headers = sharedHeaders("GetCalculationExecution");
     let body;
     body = JSON.stringify(se_GetCalculationExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCalculationExecutionCommand = se_GetCalculationExecutionCommand;
 const se_GetCalculationExecutionCodeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetCalculationExecutionCode",
-    };
+    const headers = sharedHeaders("GetCalculationExecutionCode");
     let body;
     body = JSON.stringify(se_GetCalculationExecutionCodeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCalculationExecutionCodeCommand = se_GetCalculationExecutionCodeCommand;
 const se_GetCalculationExecutionStatusCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetCalculationExecutionStatus",
-    };
+    const headers = sharedHeaders("GetCalculationExecutionStatus");
     let body;
     body = JSON.stringify(se_GetCalculationExecutionStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCalculationExecutionStatusCommand = se_GetCalculationExecutionStatusCommand;
 const se_GetDatabaseCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetDatabase",
-    };
+    const headers = sharedHeaders("GetDatabase");
     let body;
     body = JSON.stringify(se_GetDatabaseInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDatabaseCommand = se_GetDatabaseCommand;
 const se_GetDataCatalogCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetDataCatalog",
-    };
+    const headers = sharedHeaders("GetDataCatalog");
     let body;
     body = JSON.stringify(se_GetDataCatalogInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataCatalogCommand = se_GetDataCatalogCommand;
 const se_GetNamedQueryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetNamedQuery",
-    };
+    const headers = sharedHeaders("GetNamedQuery");
     let body;
     body = JSON.stringify(se_GetNamedQueryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetNamedQueryCommand = se_GetNamedQueryCommand;
 const se_GetNotebookMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetNotebookMetadata",
-    };
+    const headers = sharedHeaders("GetNotebookMetadata");
     let body;
     body = JSON.stringify(se_GetNotebookMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetNotebookMetadataCommand = se_GetNotebookMetadataCommand;
 const se_GetPreparedStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetPreparedStatement",
-    };
+    const headers = sharedHeaders("GetPreparedStatement");
     let body;
     body = JSON.stringify(se_GetPreparedStatementInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetPreparedStatementCommand = se_GetPreparedStatementCommand;
 const se_GetQueryExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetQueryExecution",
-    };
+    const headers = sharedHeaders("GetQueryExecution");
     let body;
     body = JSON.stringify(se_GetQueryExecutionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetQueryExecutionCommand = se_GetQueryExecutionCommand;
 const se_GetQueryResultsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetQueryResults",
-    };
+    const headers = sharedHeaders("GetQueryResults");
     let body;
     body = JSON.stringify(se_GetQueryResultsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetQueryResultsCommand = se_GetQueryResultsCommand;
 const se_GetQueryRuntimeStatisticsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetQueryRuntimeStatistics",
-    };
+    const headers = sharedHeaders("GetQueryRuntimeStatistics");
     let body;
     body = JSON.stringify(se_GetQueryRuntimeStatisticsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetQueryRuntimeStatisticsCommand = se_GetQueryRuntimeStatisticsCommand;
 const se_GetSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetSession",
-    };
+    const headers = sharedHeaders("GetSession");
     let body;
     body = JSON.stringify(se_GetSessionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSessionCommand = se_GetSessionCommand;
 const se_GetSessionStatusCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetSessionStatus",
-    };
+    const headers = sharedHeaders("GetSessionStatus");
     let body;
     body = JSON.stringify(se_GetSessionStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSessionStatusCommand = se_GetSessionStatusCommand;
 const se_GetTableMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetTableMetadata",
-    };
+    const headers = sharedHeaders("GetTableMetadata");
     let body;
     body = JSON.stringify(se_GetTableMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTableMetadataCommand = se_GetTableMetadataCommand;
 const se_GetWorkGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.GetWorkGroup",
-    };
+    const headers = sharedHeaders("GetWorkGroup");
     let body;
     body = JSON.stringify(se_GetWorkGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetWorkGroupCommand = se_GetWorkGroupCommand;
 const se_ImportNotebookCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ImportNotebook",
-    };
+    const headers = sharedHeaders("ImportNotebook");
     let body;
     body = JSON.stringify(se_ImportNotebookInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ImportNotebookCommand = se_ImportNotebookCommand;
 const se_ListApplicationDPUSizesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListApplicationDPUSizes",
-    };
+    const headers = sharedHeaders("ListApplicationDPUSizes");
     let body;
     body = JSON.stringify(se_ListApplicationDPUSizesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListApplicationDPUSizesCommand = se_ListApplicationDPUSizesCommand;
 const se_ListCalculationExecutionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListCalculationExecutions",
-    };
+    const headers = sharedHeaders("ListCalculationExecutions");
     let body;
     body = JSON.stringify(se_ListCalculationExecutionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCalculationExecutionsCommand = se_ListCalculationExecutionsCommand;
 const se_ListDatabasesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListDatabases",
-    };
+    const headers = sharedHeaders("ListDatabases");
     let body;
     body = JSON.stringify(se_ListDatabasesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDatabasesCommand = se_ListDatabasesCommand;
 const se_ListDataCatalogsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListDataCatalogs",
-    };
+    const headers = sharedHeaders("ListDataCatalogs");
     let body;
     body = JSON.stringify(se_ListDataCatalogsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDataCatalogsCommand = se_ListDataCatalogsCommand;
 const se_ListEngineVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListEngineVersions",
-    };
+    const headers = sharedHeaders("ListEngineVersions");
     let body;
     body = JSON.stringify(se_ListEngineVersionsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListEngineVersionsCommand = se_ListEngineVersionsCommand;
 const se_ListExecutorsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListExecutors",
-    };
+    const headers = sharedHeaders("ListExecutors");
     let body;
     body = JSON.stringify(se_ListExecutorsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListExecutorsCommand = se_ListExecutorsCommand;
 const se_ListNamedQueriesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListNamedQueries",
-    };
+    const headers = sharedHeaders("ListNamedQueries");
     let body;
     body = JSON.stringify(se_ListNamedQueriesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListNamedQueriesCommand = se_ListNamedQueriesCommand;
 const se_ListNotebookMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListNotebookMetadata",
-    };
+    const headers = sharedHeaders("ListNotebookMetadata");
     let body;
     body = JSON.stringify(se_ListNotebookMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListNotebookMetadataCommand = se_ListNotebookMetadataCommand;
 const se_ListNotebookSessionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListNotebookSessions",
-    };
+    const headers = sharedHeaders("ListNotebookSessions");
     let body;
     body = JSON.stringify(se_ListNotebookSessionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListNotebookSessionsCommand = se_ListNotebookSessionsCommand;
 const se_ListPreparedStatementsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListPreparedStatements",
-    };
+    const headers = sharedHeaders("ListPreparedStatements");
     let body;
     body = JSON.stringify(se_ListPreparedStatementsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListPreparedStatementsCommand = se_ListPreparedStatementsCommand;
 const se_ListQueryExecutionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListQueryExecutions",
-    };
+    const headers = sharedHeaders("ListQueryExecutions");
     let body;
     body = JSON.stringify(se_ListQueryExecutionsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListQueryExecutionsCommand = se_ListQueryExecutionsCommand;
 const se_ListSessionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListSessions",
-    };
+    const headers = sharedHeaders("ListSessions");
     let body;
     body = JSON.stringify(se_ListSessionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListSessionsCommand = se_ListSessionsCommand;
 const se_ListTableMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListTableMetadata",
-    };
+    const headers = sharedHeaders("ListTableMetadata");
     let body;
     body = JSON.stringify(se_ListTableMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTableMetadataCommand = se_ListTableMetadataCommand;
 const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListTagsForResource",
-    };
+    const headers = sharedHeaders("ListTagsForResource");
     let body;
     body = JSON.stringify(se_ListTagsForResourceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
 const se_ListWorkGroupsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.ListWorkGroups",
-    };
+    const headers = sharedHeaders("ListWorkGroups");
     let body;
     body = JSON.stringify(se_ListWorkGroupsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListWorkGroupsCommand = se_ListWorkGroupsCommand;
 const se_StartCalculationExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.StartCalculationExecution",
-    };
+    const headers = sharedHeaders("StartCalculationExecution");
     let body;
     body = JSON.stringify(se_StartCalculationExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartCalculationExecutionCommand = se_StartCalculationExecutionCommand;
 const se_StartQueryExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.StartQueryExecution",
-    };
+    const headers = sharedHeaders("StartQueryExecution");
     let body;
     body = JSON.stringify(se_StartQueryExecutionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartQueryExecutionCommand = se_StartQueryExecutionCommand;
 const se_StartSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.StartSession",
-    };
+    const headers = sharedHeaders("StartSession");
     let body;
     body = JSON.stringify(se_StartSessionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartSessionCommand = se_StartSessionCommand;
 const se_StopCalculationExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.StopCalculationExecution",
-    };
+    const headers = sharedHeaders("StopCalculationExecution");
     let body;
     body = JSON.stringify(se_StopCalculationExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopCalculationExecutionCommand = se_StopCalculationExecutionCommand;
 const se_StopQueryExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.StopQueryExecution",
-    };
+    const headers = sharedHeaders("StopQueryExecution");
     let body;
     body = JSON.stringify(se_StopQueryExecutionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopQueryExecutionCommand = se_StopQueryExecutionCommand;
 const se_TagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.TagResource",
-    };
+    const headers = sharedHeaders("TagResource");
     let body;
     body = JSON.stringify(se_TagResourceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_TagResourceCommand = se_TagResourceCommand;
 const se_TerminateSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.TerminateSession",
-    };
+    const headers = sharedHeaders("TerminateSession");
     let body;
     body = JSON.stringify(se_TerminateSessionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_TerminateSessionCommand = se_TerminateSessionCommand;
 const se_UntagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UntagResource",
-    };
+    const headers = sharedHeaders("UntagResource");
     let body;
     body = JSON.stringify(se_UntagResourceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UntagResourceCommand = se_UntagResourceCommand;
 const se_UpdateDataCatalogCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UpdateDataCatalog",
-    };
+    const headers = sharedHeaders("UpdateDataCatalog");
     let body;
     body = JSON.stringify(se_UpdateDataCatalogInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDataCatalogCommand = se_UpdateDataCatalogCommand;
 const se_UpdateNamedQueryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UpdateNamedQuery",
-    };
+    const headers = sharedHeaders("UpdateNamedQuery");
     let body;
     body = JSON.stringify(se_UpdateNamedQueryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateNamedQueryCommand = se_UpdateNamedQueryCommand;
 const se_UpdateNotebookCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UpdateNotebook",
-    };
+    const headers = sharedHeaders("UpdateNotebook");
     let body;
     body = JSON.stringify(se_UpdateNotebookInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateNotebookCommand = se_UpdateNotebookCommand;
 const se_UpdateNotebookMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UpdateNotebookMetadata",
-    };
+    const headers = sharedHeaders("UpdateNotebookMetadata");
     let body;
     body = JSON.stringify(se_UpdateNotebookMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateNotebookMetadataCommand = se_UpdateNotebookMetadataCommand;
 const se_UpdatePreparedStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UpdatePreparedStatement",
-    };
+    const headers = sharedHeaders("UpdatePreparedStatement");
     let body;
     body = JSON.stringify(se_UpdatePreparedStatementInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdatePreparedStatementCommand = se_UpdatePreparedStatementCommand;
 const se_UpdateWorkGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AmazonAthena.UpdateWorkGroup",
-    };
+    const headers = sharedHeaders("UpdateWorkGroup");
     let body;
     body = JSON.stringify(se_UpdateWorkGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
@@ -4774,6 +4594,12 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
     }
     return new protocol_http_1.HttpRequest(contents);
 };
+function sharedHeaders(operation) {
+    return {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": `AmazonAthena.${operation}`,
+    };
+}
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);