@aws-sdk/client-glue 3.310.0 → 3.312.0

package/dist-cjs/protocols/Aws_json1_1.js

@@ -16,2020 +16,1414 @@ const models_0_1 = require("../models/models_0");
 const models_1_1 = require("../models/models_1");
 const models_2_1 = require("../models/models_2");
 const se_BatchCreatePartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchCreatePartition",
-    };
+    const headers = sharedHeaders("BatchCreatePartition");
     let body;
     body = JSON.stringify(se_BatchCreatePartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchCreatePartitionCommand = se_BatchCreatePartitionCommand;
 const se_BatchDeleteConnectionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchDeleteConnection",
-    };
+    const headers = sharedHeaders("BatchDeleteConnection");
     let body;
     body = JSON.stringify(se_BatchDeleteConnectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchDeleteConnectionCommand = se_BatchDeleteConnectionCommand;
 const se_BatchDeletePartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchDeletePartition",
-    };
+    const headers = sharedHeaders("BatchDeletePartition");
     let body;
     body = JSON.stringify(se_BatchDeletePartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchDeletePartitionCommand = se_BatchDeletePartitionCommand;
 const se_BatchDeleteTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchDeleteTable",
-    };
+    const headers = sharedHeaders("BatchDeleteTable");
     let body;
     body = JSON.stringify(se_BatchDeleteTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchDeleteTableCommand = se_BatchDeleteTableCommand;
 const se_BatchDeleteTableVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchDeleteTableVersion",
-    };
+    const headers = sharedHeaders("BatchDeleteTableVersion");
     let body;
     body = JSON.stringify(se_BatchDeleteTableVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchDeleteTableVersionCommand = se_BatchDeleteTableVersionCommand;
 const se_BatchGetBlueprintsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetBlueprints",
-    };
+    const headers = sharedHeaders("BatchGetBlueprints");
     let body;
     body = JSON.stringify(se_BatchGetBlueprintsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetBlueprintsCommand = se_BatchGetBlueprintsCommand;
 const se_BatchGetCrawlersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetCrawlers",
-    };
+    const headers = sharedHeaders("BatchGetCrawlers");
     let body;
     body = JSON.stringify(se_BatchGetCrawlersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetCrawlersCommand = se_BatchGetCrawlersCommand;
 const se_BatchGetCustomEntityTypesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetCustomEntityTypes",
-    };
+    const headers = sharedHeaders("BatchGetCustomEntityTypes");
     let body;
     body = JSON.stringify(se_BatchGetCustomEntityTypesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetCustomEntityTypesCommand = se_BatchGetCustomEntityTypesCommand;
 const se_BatchGetDataQualityResultCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetDataQualityResult",
-    };
+    const headers = sharedHeaders("BatchGetDataQualityResult");
     let body;
     body = JSON.stringify(se_BatchGetDataQualityResultRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetDataQualityResultCommand = se_BatchGetDataQualityResultCommand;
 const se_BatchGetDevEndpointsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetDevEndpoints",
-    };
+    const headers = sharedHeaders("BatchGetDevEndpoints");
     let body;
     body = JSON.stringify(se_BatchGetDevEndpointsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetDevEndpointsCommand = se_BatchGetDevEndpointsCommand;
 const se_BatchGetJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetJobs",
-    };
+    const headers = sharedHeaders("BatchGetJobs");
     let body;
     body = JSON.stringify(se_BatchGetJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetJobsCommand = se_BatchGetJobsCommand;
 const se_BatchGetPartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetPartition",
-    };
+    const headers = sharedHeaders("BatchGetPartition");
     let body;
     body = JSON.stringify(se_BatchGetPartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetPartitionCommand = se_BatchGetPartitionCommand;
 const se_BatchGetTriggersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetTriggers",
-    };
+    const headers = sharedHeaders("BatchGetTriggers");
     let body;
     body = JSON.stringify(se_BatchGetTriggersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetTriggersCommand = se_BatchGetTriggersCommand;
 const se_BatchGetWorkflowsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchGetWorkflows",
-    };
+    const headers = sharedHeaders("BatchGetWorkflows");
     let body;
     body = JSON.stringify(se_BatchGetWorkflowsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchGetWorkflowsCommand = se_BatchGetWorkflowsCommand;
 const se_BatchStopJobRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchStopJobRun",
-    };
+    const headers = sharedHeaders("BatchStopJobRun");
     let body;
     body = JSON.stringify(se_BatchStopJobRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchStopJobRunCommand = se_BatchStopJobRunCommand;
 const se_BatchUpdatePartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.BatchUpdatePartition",
-    };
+    const headers = sharedHeaders("BatchUpdatePartition");
     let body;
     body = JSON.stringify(se_BatchUpdatePartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchUpdatePartitionCommand = se_BatchUpdatePartitionCommand;
 const se_CancelDataQualityRuleRecommendationRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CancelDataQualityRuleRecommendationRun",
-    };
+    const headers = sharedHeaders("CancelDataQualityRuleRecommendationRun");
     let body;
     body = JSON.stringify(se_CancelDataQualityRuleRecommendationRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CancelDataQualityRuleRecommendationRunCommand = se_CancelDataQualityRuleRecommendationRunCommand;
 const se_CancelDataQualityRulesetEvaluationRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CancelDataQualityRulesetEvaluationRun",
-    };
+    const headers = sharedHeaders("CancelDataQualityRulesetEvaluationRun");
     let body;
     body = JSON.stringify(se_CancelDataQualityRulesetEvaluationRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CancelDataQualityRulesetEvaluationRunCommand = se_CancelDataQualityRulesetEvaluationRunCommand;
 const se_CancelMLTaskRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CancelMLTaskRun",
-    };
+    const headers = sharedHeaders("CancelMLTaskRun");
     let body;
     body = JSON.stringify(se_CancelMLTaskRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CancelMLTaskRunCommand = se_CancelMLTaskRunCommand;
 const se_CancelStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CancelStatement",
-    };
+    const headers = sharedHeaders("CancelStatement");
     let body;
     body = JSON.stringify(se_CancelStatementRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CancelStatementCommand = se_CancelStatementCommand;
 const se_CheckSchemaVersionValidityCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CheckSchemaVersionValidity",
-    };
+    const headers = sharedHeaders("CheckSchemaVersionValidity");
     let body;
     body = JSON.stringify(se_CheckSchemaVersionValidityInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CheckSchemaVersionValidityCommand = se_CheckSchemaVersionValidityCommand;
 const se_CreateBlueprintCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateBlueprint",
-    };
+    const headers = sharedHeaders("CreateBlueprint");
     let body;
     body = JSON.stringify(se_CreateBlueprintRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateBlueprintCommand = se_CreateBlueprintCommand;
 const se_CreateClassifierCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateClassifier",
-    };
+    const headers = sharedHeaders("CreateClassifier");
     let body;
     body = JSON.stringify(se_CreateClassifierRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateClassifierCommand = se_CreateClassifierCommand;
 const se_CreateConnectionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateConnection",
-    };
+    const headers = sharedHeaders("CreateConnection");
     let body;
     body = JSON.stringify(se_CreateConnectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateConnectionCommand = se_CreateConnectionCommand;
 const se_CreateCrawlerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateCrawler",
-    };
+    const headers = sharedHeaders("CreateCrawler");
     let body;
     body = JSON.stringify(se_CreateCrawlerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateCrawlerCommand = se_CreateCrawlerCommand;
 const se_CreateCustomEntityTypeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateCustomEntityType",
-    };
+    const headers = sharedHeaders("CreateCustomEntityType");
     let body;
     body = JSON.stringify(se_CreateCustomEntityTypeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateCustomEntityTypeCommand = se_CreateCustomEntityTypeCommand;
 const se_CreateDatabaseCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateDatabase",
-    };
+    const headers = sharedHeaders("CreateDatabase");
     let body;
     body = JSON.stringify(se_CreateDatabaseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDatabaseCommand = se_CreateDatabaseCommand;
 const se_CreateDataQualityRulesetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateDataQualityRuleset",
-    };
+    const headers = sharedHeaders("CreateDataQualityRuleset");
     let body;
     body = JSON.stringify(se_CreateDataQualityRulesetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDataQualityRulesetCommand = se_CreateDataQualityRulesetCommand;
 const se_CreateDevEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateDevEndpoint",
-    };
+    const headers = sharedHeaders("CreateDevEndpoint");
     let body;
     body = JSON.stringify(se_CreateDevEndpointRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDevEndpointCommand = se_CreateDevEndpointCommand;
 const se_CreateJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateJob",
-    };
+    const headers = sharedHeaders("CreateJob");
     let body;
     body = JSON.stringify(se_CreateJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateJobCommand = se_CreateJobCommand;
 const se_CreateMLTransformCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateMLTransform",
-    };
+    const headers = sharedHeaders("CreateMLTransform");
     let body;
     body = JSON.stringify(se_CreateMLTransformRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateMLTransformCommand = se_CreateMLTransformCommand;
 const se_CreatePartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreatePartition",
-    };
+    const headers = sharedHeaders("CreatePartition");
     let body;
     body = JSON.stringify(se_CreatePartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePartitionCommand = se_CreatePartitionCommand;
 const se_CreatePartitionIndexCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreatePartitionIndex",
-    };
+    const headers = sharedHeaders("CreatePartitionIndex");
     let body;
     body = JSON.stringify(se_CreatePartitionIndexRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePartitionIndexCommand = se_CreatePartitionIndexCommand;
 const se_CreateRegistryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateRegistry",
-    };
+    const headers = sharedHeaders("CreateRegistry");
     let body;
     body = JSON.stringify(se_CreateRegistryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateRegistryCommand = se_CreateRegistryCommand;
 const se_CreateSchemaCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateSchema",
-    };
+    const headers = sharedHeaders("CreateSchema");
     let body;
     body = JSON.stringify(se_CreateSchemaInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateSchemaCommand = se_CreateSchemaCommand;
 const se_CreateScriptCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateScript",
-    };
+    const headers = sharedHeaders("CreateScript");
     let body;
     body = JSON.stringify(se_CreateScriptRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateScriptCommand = se_CreateScriptCommand;
 const se_CreateSecurityConfigurationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateSecurityConfiguration",
-    };
+    const headers = sharedHeaders("CreateSecurityConfiguration");
     let body;
     body = JSON.stringify(se_CreateSecurityConfigurationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateSecurityConfigurationCommand = se_CreateSecurityConfigurationCommand;
 const se_CreateSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateSession",
-    };
+    const headers = sharedHeaders("CreateSession");
     let body;
     body = JSON.stringify(se_CreateSessionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateSessionCommand = se_CreateSessionCommand;
 const se_CreateTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateTable",
-    };
+    const headers = sharedHeaders("CreateTable");
     let body;
     body = JSON.stringify(se_CreateTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateTableCommand = se_CreateTableCommand;
 const se_CreateTriggerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateTrigger",
-    };
+    const headers = sharedHeaders("CreateTrigger");
     let body;
     body = JSON.stringify(se_CreateTriggerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateTriggerCommand = se_CreateTriggerCommand;
 const se_CreateUserDefinedFunctionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateUserDefinedFunction",
-    };
+    const headers = sharedHeaders("CreateUserDefinedFunction");
     let body;
     body = JSON.stringify(se_CreateUserDefinedFunctionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateUserDefinedFunctionCommand = se_CreateUserDefinedFunctionCommand;
 const se_CreateWorkflowCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.CreateWorkflow",
-    };
+    const headers = sharedHeaders("CreateWorkflow");
     let body;
     body = JSON.stringify(se_CreateWorkflowRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateWorkflowCommand = se_CreateWorkflowCommand;
 const se_DeleteBlueprintCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteBlueprint",
-    };
+    const headers = sharedHeaders("DeleteBlueprint");
     let body;
     body = JSON.stringify(se_DeleteBlueprintRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteBlueprintCommand = se_DeleteBlueprintCommand;
 const se_DeleteClassifierCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteClassifier",
-    };
+    const headers = sharedHeaders("DeleteClassifier");
     let body;
     body = JSON.stringify(se_DeleteClassifierRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteClassifierCommand = se_DeleteClassifierCommand;
 const se_DeleteColumnStatisticsForPartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteColumnStatisticsForPartition",
-    };
+    const headers = sharedHeaders("DeleteColumnStatisticsForPartition");
     let body;
     body = JSON.stringify(se_DeleteColumnStatisticsForPartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteColumnStatisticsForPartitionCommand = se_DeleteColumnStatisticsForPartitionCommand;
 const se_DeleteColumnStatisticsForTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteColumnStatisticsForTable",
-    };
+    const headers = sharedHeaders("DeleteColumnStatisticsForTable");
     let body;
     body = JSON.stringify(se_DeleteColumnStatisticsForTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteColumnStatisticsForTableCommand = se_DeleteColumnStatisticsForTableCommand;
 const se_DeleteConnectionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteConnection",
-    };
+    const headers = sharedHeaders("DeleteConnection");
     let body;
     body = JSON.stringify(se_DeleteConnectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteConnectionCommand = se_DeleteConnectionCommand;
 const se_DeleteCrawlerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteCrawler",
-    };
+    const headers = sharedHeaders("DeleteCrawler");
     let body;
     body = JSON.stringify(se_DeleteCrawlerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteCrawlerCommand = se_DeleteCrawlerCommand;
 const se_DeleteCustomEntityTypeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteCustomEntityType",
-    };
+    const headers = sharedHeaders("DeleteCustomEntityType");
     let body;
     body = JSON.stringify(se_DeleteCustomEntityTypeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteCustomEntityTypeCommand = se_DeleteCustomEntityTypeCommand;
 const se_DeleteDatabaseCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteDatabase",
-    };
+    const headers = sharedHeaders("DeleteDatabase");
     let body;
     body = JSON.stringify(se_DeleteDatabaseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDatabaseCommand = se_DeleteDatabaseCommand;
 const se_DeleteDataQualityRulesetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteDataQualityRuleset",
-    };
+    const headers = sharedHeaders("DeleteDataQualityRuleset");
     let body;
     body = JSON.stringify(se_DeleteDataQualityRulesetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDataQualityRulesetCommand = se_DeleteDataQualityRulesetCommand;
 const se_DeleteDevEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteDevEndpoint",
-    };
+    const headers = sharedHeaders("DeleteDevEndpoint");
     let body;
     body = JSON.stringify(se_DeleteDevEndpointRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDevEndpointCommand = se_DeleteDevEndpointCommand;
 const se_DeleteJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteJob",
-    };
+    const headers = sharedHeaders("DeleteJob");
     let body;
     body = JSON.stringify(se_DeleteJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteJobCommand = se_DeleteJobCommand;
 const se_DeleteMLTransformCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteMLTransform",
-    };
+    const headers = sharedHeaders("DeleteMLTransform");
     let body;
     body = JSON.stringify(se_DeleteMLTransformRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteMLTransformCommand = se_DeleteMLTransformCommand;
 const se_DeletePartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeletePartition",
-    };
+    const headers = sharedHeaders("DeletePartition");
     let body;
     body = JSON.stringify(se_DeletePartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeletePartitionCommand = se_DeletePartitionCommand;
 const se_DeletePartitionIndexCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeletePartitionIndex",
-    };
+    const headers = sharedHeaders("DeletePartitionIndex");
     let body;
     body = JSON.stringify(se_DeletePartitionIndexRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeletePartitionIndexCommand = se_DeletePartitionIndexCommand;
 const se_DeleteRegistryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteRegistry",
-    };
+    const headers = sharedHeaders("DeleteRegistry");
     let body;
     body = JSON.stringify(se_DeleteRegistryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteRegistryCommand = se_DeleteRegistryCommand;
 const se_DeleteResourcePolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteResourcePolicy",
-    };
+    const headers = sharedHeaders("DeleteResourcePolicy");
     let body;
     body = JSON.stringify(se_DeleteResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteResourcePolicyCommand = se_DeleteResourcePolicyCommand;
 const se_DeleteSchemaCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteSchema",
-    };
+    const headers = sharedHeaders("DeleteSchema");
     let body;
     body = JSON.stringify(se_DeleteSchemaInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteSchemaCommand = se_DeleteSchemaCommand;
 const se_DeleteSchemaVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteSchemaVersions",
-    };
+    const headers = sharedHeaders("DeleteSchemaVersions");
     let body;
     body = JSON.stringify(se_DeleteSchemaVersionsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteSchemaVersionsCommand = se_DeleteSchemaVersionsCommand;
 const se_DeleteSecurityConfigurationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteSecurityConfiguration",
-    };
+    const headers = sharedHeaders("DeleteSecurityConfiguration");
     let body;
     body = JSON.stringify(se_DeleteSecurityConfigurationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteSecurityConfigurationCommand = se_DeleteSecurityConfigurationCommand;
 const se_DeleteSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteSession",
-    };
+    const headers = sharedHeaders("DeleteSession");
     let body;
     body = JSON.stringify(se_DeleteSessionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteSessionCommand = se_DeleteSessionCommand;
 const se_DeleteTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteTable",
-    };
+    const headers = sharedHeaders("DeleteTable");
     let body;
     body = JSON.stringify(se_DeleteTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteTableCommand = se_DeleteTableCommand;
 const se_DeleteTableVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteTableVersion",
-    };
+    const headers = sharedHeaders("DeleteTableVersion");
     let body;
     body = JSON.stringify(se_DeleteTableVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteTableVersionCommand = se_DeleteTableVersionCommand;
 const se_DeleteTriggerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteTrigger",
-    };
+    const headers = sharedHeaders("DeleteTrigger");
     let body;
     body = JSON.stringify(se_DeleteTriggerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteTriggerCommand = se_DeleteTriggerCommand;
 const se_DeleteUserDefinedFunctionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteUserDefinedFunction",
-    };
+    const headers = sharedHeaders("DeleteUserDefinedFunction");
     let body;
     body = JSON.stringify(se_DeleteUserDefinedFunctionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserDefinedFunctionCommand = se_DeleteUserDefinedFunctionCommand;
 const se_DeleteWorkflowCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.DeleteWorkflow",
-    };
+    const headers = sharedHeaders("DeleteWorkflow");
     let body;
     body = JSON.stringify(se_DeleteWorkflowRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteWorkflowCommand = se_DeleteWorkflowCommand;
 const se_GetBlueprintCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetBlueprint",
-    };
+    const headers = sharedHeaders("GetBlueprint");
     let body;
     body = JSON.stringify(se_GetBlueprintRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetBlueprintCommand = se_GetBlueprintCommand;
 const se_GetBlueprintRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetBlueprintRun",
-    };
+    const headers = sharedHeaders("GetBlueprintRun");
     let body;
     body = JSON.stringify(se_GetBlueprintRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetBlueprintRunCommand = se_GetBlueprintRunCommand;
 const se_GetBlueprintRunsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetBlueprintRuns",
-    };
+    const headers = sharedHeaders("GetBlueprintRuns");
     let body;
     body = JSON.stringify(se_GetBlueprintRunsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetBlueprintRunsCommand = se_GetBlueprintRunsCommand;
 const se_GetCatalogImportStatusCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetCatalogImportStatus",
-    };
+    const headers = sharedHeaders("GetCatalogImportStatus");
     let body;
     body = JSON.stringify(se_GetCatalogImportStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCatalogImportStatusCommand = se_GetCatalogImportStatusCommand;
 const se_GetClassifierCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetClassifier",
-    };
+    const headers = sharedHeaders("GetClassifier");
     let body;
     body = JSON.stringify(se_GetClassifierRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetClassifierCommand = se_GetClassifierCommand;
 const se_GetClassifiersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetClassifiers",
-    };
+    const headers = sharedHeaders("GetClassifiers");
     let body;
     body = JSON.stringify(se_GetClassifiersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetClassifiersCommand = se_GetClassifiersCommand;
 const se_GetColumnStatisticsForPartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetColumnStatisticsForPartition",
-    };
+    const headers = sharedHeaders("GetColumnStatisticsForPartition");
     let body;
     body = JSON.stringify(se_GetColumnStatisticsForPartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetColumnStatisticsForPartitionCommand = se_GetColumnStatisticsForPartitionCommand;
 const se_GetColumnStatisticsForTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetColumnStatisticsForTable",
-    };
+    const headers = sharedHeaders("GetColumnStatisticsForTable");
     let body;
     body = JSON.stringify(se_GetColumnStatisticsForTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetColumnStatisticsForTableCommand = se_GetColumnStatisticsForTableCommand;
 const se_GetConnectionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetConnection",
-    };
+    const headers = sharedHeaders("GetConnection");
     let body;
     body = JSON.stringify(se_GetConnectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetConnectionCommand = se_GetConnectionCommand;
 const se_GetConnectionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetConnections",
-    };
+    const headers = sharedHeaders("GetConnections");
     let body;
     body = JSON.stringify(se_GetConnectionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetConnectionsCommand = se_GetConnectionsCommand;
 const se_GetCrawlerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetCrawler",
-    };
+    const headers = sharedHeaders("GetCrawler");
     let body;
     body = JSON.stringify(se_GetCrawlerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCrawlerCommand = se_GetCrawlerCommand;
 const se_GetCrawlerMetricsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetCrawlerMetrics",
-    };
+    const headers = sharedHeaders("GetCrawlerMetrics");
     let body;
     body = JSON.stringify(se_GetCrawlerMetricsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCrawlerMetricsCommand = se_GetCrawlerMetricsCommand;
 const se_GetCrawlersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetCrawlers",
-    };
+    const headers = sharedHeaders("GetCrawlers");
     let body;
     body = JSON.stringify(se_GetCrawlersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCrawlersCommand = se_GetCrawlersCommand;
 const se_GetCustomEntityTypeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetCustomEntityType",
-    };
+    const headers = sharedHeaders("GetCustomEntityType");
     let body;
     body = JSON.stringify(se_GetCustomEntityTypeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCustomEntityTypeCommand = se_GetCustomEntityTypeCommand;
 const se_GetDatabaseCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDatabase",
-    };
+    const headers = sharedHeaders("GetDatabase");
     let body;
     body = JSON.stringify(se_GetDatabaseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDatabaseCommand = se_GetDatabaseCommand;
 const se_GetDatabasesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDatabases",
-    };
+    const headers = sharedHeaders("GetDatabases");
     let body;
     body = JSON.stringify(se_GetDatabasesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDatabasesCommand = se_GetDatabasesCommand;
 const se_GetDataCatalogEncryptionSettingsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDataCatalogEncryptionSettings",
-    };
+    const headers = sharedHeaders("GetDataCatalogEncryptionSettings");
     let body;
     body = JSON.stringify(se_GetDataCatalogEncryptionSettingsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataCatalogEncryptionSettingsCommand = se_GetDataCatalogEncryptionSettingsCommand;
 const se_GetDataflowGraphCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDataflowGraph",
-    };
+    const headers = sharedHeaders("GetDataflowGraph");
     let body;
     body = JSON.stringify(se_GetDataflowGraphRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataflowGraphCommand = se_GetDataflowGraphCommand;
 const se_GetDataQualityResultCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDataQualityResult",
-    };
+    const headers = sharedHeaders("GetDataQualityResult");
     let body;
     body = JSON.stringify(se_GetDataQualityResultRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataQualityResultCommand = se_GetDataQualityResultCommand;
 const se_GetDataQualityRuleRecommendationRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDataQualityRuleRecommendationRun",
-    };
+    const headers = sharedHeaders("GetDataQualityRuleRecommendationRun");
     let body;
     body = JSON.stringify(se_GetDataQualityRuleRecommendationRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataQualityRuleRecommendationRunCommand = se_GetDataQualityRuleRecommendationRunCommand;
 const se_GetDataQualityRulesetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDataQualityRuleset",
-    };
+    const headers = sharedHeaders("GetDataQualityRuleset");
     let body;
     body = JSON.stringify(se_GetDataQualityRulesetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataQualityRulesetCommand = se_GetDataQualityRulesetCommand;
 const se_GetDataQualityRulesetEvaluationRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDataQualityRulesetEvaluationRun",
-    };
+    const headers = sharedHeaders("GetDataQualityRulesetEvaluationRun");
     let body;
     body = JSON.stringify(se_GetDataQualityRulesetEvaluationRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDataQualityRulesetEvaluationRunCommand = se_GetDataQualityRulesetEvaluationRunCommand;
 const se_GetDevEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDevEndpoint",
-    };
+    const headers = sharedHeaders("GetDevEndpoint");
     let body;
     body = JSON.stringify(se_GetDevEndpointRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDevEndpointCommand = se_GetDevEndpointCommand;
 const se_GetDevEndpointsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetDevEndpoints",
-    };
+    const headers = sharedHeaders("GetDevEndpoints");
     let body;
     body = JSON.stringify(se_GetDevEndpointsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDevEndpointsCommand = se_GetDevEndpointsCommand;
 const se_GetJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetJob",
-    };
+    const headers = sharedHeaders("GetJob");
     let body;
     body = JSON.stringify(se_GetJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetJobCommand = se_GetJobCommand;
 const se_GetJobBookmarkCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetJobBookmark",
-    };
+    const headers = sharedHeaders("GetJobBookmark");
     let body;
     body = JSON.stringify(se_GetJobBookmarkRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetJobBookmarkCommand = se_GetJobBookmarkCommand;
 const se_GetJobRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetJobRun",
-    };
+    const headers = sharedHeaders("GetJobRun");
     let body;
     body = JSON.stringify(se_GetJobRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetJobRunCommand = se_GetJobRunCommand;
 const se_GetJobRunsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetJobRuns",
-    };
+    const headers = sharedHeaders("GetJobRuns");
     let body;
     body = JSON.stringify(se_GetJobRunsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetJobRunsCommand = se_GetJobRunsCommand;
 const se_GetJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetJobs",
-    };
+    const headers = sharedHeaders("GetJobs");
     let body;
     body = JSON.stringify(se_GetJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetJobsCommand = se_GetJobsCommand;
 const se_GetMappingCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetMapping",
-    };
+    const headers = sharedHeaders("GetMapping");
     let body;
     body = JSON.stringify(se_GetMappingRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetMappingCommand = se_GetMappingCommand;
 const se_GetMLTaskRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetMLTaskRun",
-    };
+    const headers = sharedHeaders("GetMLTaskRun");
     let body;
     body = JSON.stringify(se_GetMLTaskRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetMLTaskRunCommand = se_GetMLTaskRunCommand;
 const se_GetMLTaskRunsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetMLTaskRuns",
-    };
+    const headers = sharedHeaders("GetMLTaskRuns");
     let body;
     body = JSON.stringify(se_GetMLTaskRunsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetMLTaskRunsCommand = se_GetMLTaskRunsCommand;
 const se_GetMLTransformCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetMLTransform",
-    };
+    const headers = sharedHeaders("GetMLTransform");
     let body;
     body = JSON.stringify(se_GetMLTransformRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetMLTransformCommand = se_GetMLTransformCommand;
 const se_GetMLTransformsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetMLTransforms",
-    };
+    const headers = sharedHeaders("GetMLTransforms");
     let body;
     body = JSON.stringify(se_GetMLTransformsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetMLTransformsCommand = se_GetMLTransformsCommand;
 const se_GetPartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetPartition",
-    };
+    const headers = sharedHeaders("GetPartition");
     let body;
     body = JSON.stringify(se_GetPartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetPartitionCommand = se_GetPartitionCommand;
 const se_GetPartitionIndexesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetPartitionIndexes",
-    };
+    const headers = sharedHeaders("GetPartitionIndexes");
     let body;
     body = JSON.stringify(se_GetPartitionIndexesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetPartitionIndexesCommand = se_GetPartitionIndexesCommand;
 const se_GetPartitionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetPartitions",
-    };
+    const headers = sharedHeaders("GetPartitions");
     let body;
     body = JSON.stringify(se_GetPartitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetPartitionsCommand = se_GetPartitionsCommand;
 const se_GetPlanCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetPlan",
-    };
+    const headers = sharedHeaders("GetPlan");
     let body;
     body = JSON.stringify(se_GetPlanRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetPlanCommand = se_GetPlanCommand;
 const se_GetRegistryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetRegistry",
-    };
+    const headers = sharedHeaders("GetRegistry");
     let body;
     body = JSON.stringify(se_GetRegistryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetRegistryCommand = se_GetRegistryCommand;
 const se_GetResourcePoliciesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetResourcePolicies",
-    };
+    const headers = sharedHeaders("GetResourcePolicies");
     let body;
     body = JSON.stringify(se_GetResourcePoliciesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetResourcePoliciesCommand = se_GetResourcePoliciesCommand;
 const se_GetResourcePolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetResourcePolicy",
-    };
+    const headers = sharedHeaders("GetResourcePolicy");
     let body;
     body = JSON.stringify(se_GetResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetResourcePolicyCommand = se_GetResourcePolicyCommand;
 const se_GetSchemaCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetSchema",
-    };
+    const headers = sharedHeaders("GetSchema");
     let body;
     body = JSON.stringify(se_GetSchemaInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSchemaCommand = se_GetSchemaCommand;
 const se_GetSchemaByDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetSchemaByDefinition",
-    };
+    const headers = sharedHeaders("GetSchemaByDefinition");
     let body;
     body = JSON.stringify(se_GetSchemaByDefinitionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSchemaByDefinitionCommand = se_GetSchemaByDefinitionCommand;
 const se_GetSchemaVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetSchemaVersion",
-    };
+    const headers = sharedHeaders("GetSchemaVersion");
     let body;
     body = JSON.stringify(se_GetSchemaVersionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSchemaVersionCommand = se_GetSchemaVersionCommand;
 const se_GetSchemaVersionsDiffCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetSchemaVersionsDiff",
-    };
+    const headers = sharedHeaders("GetSchemaVersionsDiff");
     let body;
     body = JSON.stringify(se_GetSchemaVersionsDiffInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSchemaVersionsDiffCommand = se_GetSchemaVersionsDiffCommand;
 const se_GetSecurityConfigurationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetSecurityConfiguration",
-    };
+    const headers = sharedHeaders("GetSecurityConfiguration");
     let body;
     body = JSON.stringify(se_GetSecurityConfigurationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSecurityConfigurationCommand = se_GetSecurityConfigurationCommand;
 const se_GetSecurityConfigurationsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetSecurityConfigurations",
-    };
+    const headers = sharedHeaders("GetSecurityConfigurations");
     let body;
     body = JSON.stringify(se_GetSecurityConfigurationsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSecurityConfigurationsCommand = se_GetSecurityConfigurationsCommand;
 const se_GetSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.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_GetStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetStatement",
-    };
+    const headers = sharedHeaders("GetStatement");
     let body;
     body = JSON.stringify(se_GetStatementRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetStatementCommand = se_GetStatementCommand;
 const se_GetTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTable",
-    };
+    const headers = sharedHeaders("GetTable");
     let body;
     body = JSON.stringify(se_GetTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTableCommand = se_GetTableCommand;
 const se_GetTablesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTables",
-    };
+    const headers = sharedHeaders("GetTables");
     let body;
     body = JSON.stringify(se_GetTablesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTablesCommand = se_GetTablesCommand;
 const se_GetTableVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTableVersion",
-    };
+    const headers = sharedHeaders("GetTableVersion");
     let body;
     body = JSON.stringify(se_GetTableVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTableVersionCommand = se_GetTableVersionCommand;
 const se_GetTableVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTableVersions",
-    };
+    const headers = sharedHeaders("GetTableVersions");
     let body;
     body = JSON.stringify(se_GetTableVersionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTableVersionsCommand = se_GetTableVersionsCommand;
 const se_GetTagsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTags",
-    };
+    const headers = sharedHeaders("GetTags");
     let body;
     body = JSON.stringify(se_GetTagsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTagsCommand = se_GetTagsCommand;
 const se_GetTriggerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTrigger",
-    };
+    const headers = sharedHeaders("GetTrigger");
     let body;
     body = JSON.stringify(se_GetTriggerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTriggerCommand = se_GetTriggerCommand;
 const se_GetTriggersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetTriggers",
-    };
+    const headers = sharedHeaders("GetTriggers");
     let body;
     body = JSON.stringify(se_GetTriggersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetTriggersCommand = se_GetTriggersCommand;
 const se_GetUnfilteredPartitionMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetUnfilteredPartitionMetadata",
-    };
+    const headers = sharedHeaders("GetUnfilteredPartitionMetadata");
     let body;
     body = JSON.stringify(se_GetUnfilteredPartitionMetadataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUnfilteredPartitionMetadataCommand = se_GetUnfilteredPartitionMetadataCommand;
 const se_GetUnfilteredPartitionsMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetUnfilteredPartitionsMetadata",
-    };
+    const headers = sharedHeaders("GetUnfilteredPartitionsMetadata");
     let body;
     body = JSON.stringify(se_GetUnfilteredPartitionsMetadataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUnfilteredPartitionsMetadataCommand = se_GetUnfilteredPartitionsMetadataCommand;
 const se_GetUnfilteredTableMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetUnfilteredTableMetadata",
-    };
+    const headers = sharedHeaders("GetUnfilteredTableMetadata");
     let body;
     body = JSON.stringify(se_GetUnfilteredTableMetadataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUnfilteredTableMetadataCommand = se_GetUnfilteredTableMetadataCommand;
 const se_GetUserDefinedFunctionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetUserDefinedFunction",
-    };
+    const headers = sharedHeaders("GetUserDefinedFunction");
     let body;
     body = JSON.stringify(se_GetUserDefinedFunctionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUserDefinedFunctionCommand = se_GetUserDefinedFunctionCommand;
 const se_GetUserDefinedFunctionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetUserDefinedFunctions",
-    };
+    const headers = sharedHeaders("GetUserDefinedFunctions");
     let body;
     body = JSON.stringify(se_GetUserDefinedFunctionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUserDefinedFunctionsCommand = se_GetUserDefinedFunctionsCommand;
 const se_GetWorkflowCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetWorkflow",
-    };
+    const headers = sharedHeaders("GetWorkflow");
     let body;
     body = JSON.stringify(se_GetWorkflowRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetWorkflowCommand = se_GetWorkflowCommand;
 const se_GetWorkflowRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetWorkflowRun",
-    };
+    const headers = sharedHeaders("GetWorkflowRun");
     let body;
     body = JSON.stringify(se_GetWorkflowRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetWorkflowRunCommand = se_GetWorkflowRunCommand;
 const se_GetWorkflowRunPropertiesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetWorkflowRunProperties",
-    };
+    const headers = sharedHeaders("GetWorkflowRunProperties");
     let body;
     body = JSON.stringify(se_GetWorkflowRunPropertiesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetWorkflowRunPropertiesCommand = se_GetWorkflowRunPropertiesCommand;
 const se_GetWorkflowRunsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.GetWorkflowRuns",
-    };
+    const headers = sharedHeaders("GetWorkflowRuns");
     let body;
     body = JSON.stringify(se_GetWorkflowRunsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetWorkflowRunsCommand = se_GetWorkflowRunsCommand;
 const se_ImportCatalogToGlueCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ImportCatalogToGlue",
-    };
+    const headers = sharedHeaders("ImportCatalogToGlue");
     let body;
     body = JSON.stringify(se_ImportCatalogToGlueRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ImportCatalogToGlueCommand = se_ImportCatalogToGlueCommand;
 const se_ListBlueprintsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListBlueprints",
-    };
+    const headers = sharedHeaders("ListBlueprints");
     let body;
     body = JSON.stringify(se_ListBlueprintsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListBlueprintsCommand = se_ListBlueprintsCommand;
 const se_ListCrawlersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListCrawlers",
-    };
+    const headers = sharedHeaders("ListCrawlers");
     let body;
     body = JSON.stringify(se_ListCrawlersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCrawlersCommand = se_ListCrawlersCommand;
 const se_ListCrawlsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListCrawls",
-    };
+    const headers = sharedHeaders("ListCrawls");
     let body;
     body = JSON.stringify(se_ListCrawlsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCrawlsCommand = se_ListCrawlsCommand;
 const se_ListCustomEntityTypesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListCustomEntityTypes",
-    };
+    const headers = sharedHeaders("ListCustomEntityTypes");
     let body;
     body = JSON.stringify(se_ListCustomEntityTypesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCustomEntityTypesCommand = se_ListCustomEntityTypesCommand;
 const se_ListDataQualityResultsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListDataQualityResults",
-    };
+    const headers = sharedHeaders("ListDataQualityResults");
     let body;
     body = JSON.stringify(se_ListDataQualityResultsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDataQualityResultsCommand = se_ListDataQualityResultsCommand;
 const se_ListDataQualityRuleRecommendationRunsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListDataQualityRuleRecommendationRuns",
-    };
+    const headers = sharedHeaders("ListDataQualityRuleRecommendationRuns");
     let body;
     body = JSON.stringify(se_ListDataQualityRuleRecommendationRunsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDataQualityRuleRecommendationRunsCommand = se_ListDataQualityRuleRecommendationRunsCommand;
 const se_ListDataQualityRulesetEvaluationRunsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListDataQualityRulesetEvaluationRuns",
-    };
+    const headers = sharedHeaders("ListDataQualityRulesetEvaluationRuns");
     let body;
     body = JSON.stringify(se_ListDataQualityRulesetEvaluationRunsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDataQualityRulesetEvaluationRunsCommand = se_ListDataQualityRulesetEvaluationRunsCommand;
 const se_ListDataQualityRulesetsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListDataQualityRulesets",
-    };
+    const headers = sharedHeaders("ListDataQualityRulesets");
     let body;
     body = JSON.stringify(se_ListDataQualityRulesetsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDataQualityRulesetsCommand = se_ListDataQualityRulesetsCommand;
 const se_ListDevEndpointsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListDevEndpoints",
-    };
+    const headers = sharedHeaders("ListDevEndpoints");
     let body;
     body = JSON.stringify(se_ListDevEndpointsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDevEndpointsCommand = se_ListDevEndpointsCommand;
 const se_ListJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListJobs",
-    };
+    const headers = sharedHeaders("ListJobs");
     let body;
     body = JSON.stringify(se_ListJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListJobsCommand = se_ListJobsCommand;
 const se_ListMLTransformsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListMLTransforms",
-    };
+    const headers = sharedHeaders("ListMLTransforms");
     let body;
     body = JSON.stringify(se_ListMLTransformsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListMLTransformsCommand = se_ListMLTransformsCommand;
 const se_ListRegistriesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListRegistries",
-    };
+    const headers = sharedHeaders("ListRegistries");
     let body;
     body = JSON.stringify(se_ListRegistriesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListRegistriesCommand = se_ListRegistriesCommand;
 const se_ListSchemasCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListSchemas",
-    };
+    const headers = sharedHeaders("ListSchemas");
     let body;
     body = JSON.stringify(se_ListSchemasInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListSchemasCommand = se_ListSchemasCommand;
 const se_ListSchemaVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListSchemaVersions",
-    };
+    const headers = sharedHeaders("ListSchemaVersions");
     let body;
     body = JSON.stringify(se_ListSchemaVersionsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListSchemaVersionsCommand = se_ListSchemaVersionsCommand;
 const se_ListSessionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.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_ListStatementsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListStatements",
-    };
+    const headers = sharedHeaders("ListStatements");
     let body;
     body = JSON.stringify(se_ListStatementsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListStatementsCommand = se_ListStatementsCommand;
 const se_ListTriggersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListTriggers",
-    };
+    const headers = sharedHeaders("ListTriggers");
     let body;
     body = JSON.stringify(se_ListTriggersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTriggersCommand = se_ListTriggersCommand;
 const se_ListWorkflowsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ListWorkflows",
-    };
+    const headers = sharedHeaders("ListWorkflows");
     let body;
     body = JSON.stringify(se_ListWorkflowsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListWorkflowsCommand = se_ListWorkflowsCommand;
 const se_PutDataCatalogEncryptionSettingsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.PutDataCatalogEncryptionSettings",
-    };
+    const headers = sharedHeaders("PutDataCatalogEncryptionSettings");
     let body;
     body = JSON.stringify(se_PutDataCatalogEncryptionSettingsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_PutDataCatalogEncryptionSettingsCommand = se_PutDataCatalogEncryptionSettingsCommand;
 const se_PutResourcePolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.PutResourcePolicy",
-    };
+    const headers = sharedHeaders("PutResourcePolicy");
     let body;
     body = JSON.stringify(se_PutResourcePolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_PutResourcePolicyCommand = se_PutResourcePolicyCommand;
 const se_PutSchemaVersionMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.PutSchemaVersionMetadata",
-    };
+    const headers = sharedHeaders("PutSchemaVersionMetadata");
     let body;
     body = JSON.stringify(se_PutSchemaVersionMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_PutSchemaVersionMetadataCommand = se_PutSchemaVersionMetadataCommand;
 const se_PutWorkflowRunPropertiesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.PutWorkflowRunProperties",
-    };
+    const headers = sharedHeaders("PutWorkflowRunProperties");
     let body;
     body = JSON.stringify(se_PutWorkflowRunPropertiesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_PutWorkflowRunPropertiesCommand = se_PutWorkflowRunPropertiesCommand;
 const se_QuerySchemaVersionMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.QuerySchemaVersionMetadata",
-    };
+    const headers = sharedHeaders("QuerySchemaVersionMetadata");
     let body;
     body = JSON.stringify(se_QuerySchemaVersionMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_QuerySchemaVersionMetadataCommand = se_QuerySchemaVersionMetadataCommand;
 const se_RegisterSchemaVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.RegisterSchemaVersion",
-    };
+    const headers = sharedHeaders("RegisterSchemaVersion");
     let body;
     body = JSON.stringify(se_RegisterSchemaVersionInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RegisterSchemaVersionCommand = se_RegisterSchemaVersionCommand;
 const se_RemoveSchemaVersionMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.RemoveSchemaVersionMetadata",
-    };
+    const headers = sharedHeaders("RemoveSchemaVersionMetadata");
     let body;
     body = JSON.stringify(se_RemoveSchemaVersionMetadataInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RemoveSchemaVersionMetadataCommand = se_RemoveSchemaVersionMetadataCommand;
 const se_ResetJobBookmarkCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ResetJobBookmark",
-    };
+    const headers = sharedHeaders("ResetJobBookmark");
     let body;
     body = JSON.stringify(se_ResetJobBookmarkRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ResetJobBookmarkCommand = se_ResetJobBookmarkCommand;
 const se_ResumeWorkflowRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.ResumeWorkflowRun",
-    };
+    const headers = sharedHeaders("ResumeWorkflowRun");
     let body;
     body = JSON.stringify(se_ResumeWorkflowRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ResumeWorkflowRunCommand = se_ResumeWorkflowRunCommand;
 const se_RunStatementCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.RunStatement",
-    };
+    const headers = sharedHeaders("RunStatement");
     let body;
     body = JSON.stringify(se_RunStatementRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RunStatementCommand = se_RunStatementCommand;
 const se_SearchTablesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.SearchTables",
-    };
+    const headers = sharedHeaders("SearchTables");
     let body;
     body = JSON.stringify(se_SearchTablesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SearchTablesCommand = se_SearchTablesCommand;
 const se_StartBlueprintRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartBlueprintRun",
-    };
+    const headers = sharedHeaders("StartBlueprintRun");
     let body;
     body = JSON.stringify(se_StartBlueprintRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartBlueprintRunCommand = se_StartBlueprintRunCommand;
 const se_StartCrawlerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartCrawler",
-    };
+    const headers = sharedHeaders("StartCrawler");
     let body;
     body = JSON.stringify(se_StartCrawlerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartCrawlerCommand = se_StartCrawlerCommand;
 const se_StartCrawlerScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartCrawlerSchedule",
-    };
+    const headers = sharedHeaders("StartCrawlerSchedule");
     let body;
     body = JSON.stringify(se_StartCrawlerScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartCrawlerScheduleCommand = se_StartCrawlerScheduleCommand;
 const se_StartDataQualityRuleRecommendationRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartDataQualityRuleRecommendationRun",
-    };
+    const headers = sharedHeaders("StartDataQualityRuleRecommendationRun");
     let body;
     body = JSON.stringify(se_StartDataQualityRuleRecommendationRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartDataQualityRuleRecommendationRunCommand = se_StartDataQualityRuleRecommendationRunCommand;
 const se_StartDataQualityRulesetEvaluationRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartDataQualityRulesetEvaluationRun",
-    };
+    const headers = sharedHeaders("StartDataQualityRulesetEvaluationRun");
     let body;
     body = JSON.stringify(se_StartDataQualityRulesetEvaluationRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartDataQualityRulesetEvaluationRunCommand = se_StartDataQualityRulesetEvaluationRunCommand;
 const se_StartExportLabelsTaskRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartExportLabelsTaskRun",
-    };
+    const headers = sharedHeaders("StartExportLabelsTaskRun");
     let body;
     body = JSON.stringify(se_StartExportLabelsTaskRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartExportLabelsTaskRunCommand = se_StartExportLabelsTaskRunCommand;
 const se_StartImportLabelsTaskRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartImportLabelsTaskRun",
-    };
+    const headers = sharedHeaders("StartImportLabelsTaskRun");
     let body;
     body = JSON.stringify(se_StartImportLabelsTaskRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartImportLabelsTaskRunCommand = se_StartImportLabelsTaskRunCommand;
 const se_StartJobRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartJobRun",
-    };
+    const headers = sharedHeaders("StartJobRun");
     let body;
     body = JSON.stringify(se_StartJobRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartJobRunCommand = se_StartJobRunCommand;
 const se_StartMLEvaluationTaskRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartMLEvaluationTaskRun",
-    };
+    const headers = sharedHeaders("StartMLEvaluationTaskRun");
     let body;
     body = JSON.stringify(se_StartMLEvaluationTaskRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartMLEvaluationTaskRunCommand = se_StartMLEvaluationTaskRunCommand;
 const se_StartMLLabelingSetGenerationTaskRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartMLLabelingSetGenerationTaskRun",
-    };
+    const headers = sharedHeaders("StartMLLabelingSetGenerationTaskRun");
     let body;
     body = JSON.stringify(se_StartMLLabelingSetGenerationTaskRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartMLLabelingSetGenerationTaskRunCommand = se_StartMLLabelingSetGenerationTaskRunCommand;
 const se_StartTriggerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartTrigger",
-    };
+    const headers = sharedHeaders("StartTrigger");
     let body;
     body = JSON.stringify(se_StartTriggerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartTriggerCommand = se_StartTriggerCommand;
 const se_StartWorkflowRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StartWorkflowRun",
-    };
+    const headers = sharedHeaders("StartWorkflowRun");
     let body;
     body = JSON.stringify(se_StartWorkflowRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartWorkflowRunCommand = se_StartWorkflowRunCommand;
 const se_StopCrawlerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StopCrawler",
-    };
+    const headers = sharedHeaders("StopCrawler");
     let body;
     body = JSON.stringify(se_StopCrawlerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopCrawlerCommand = se_StopCrawlerCommand;
 const se_StopCrawlerScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StopCrawlerSchedule",
-    };
+    const headers = sharedHeaders("StopCrawlerSchedule");
     let body;
     body = JSON.stringify(se_StopCrawlerScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopCrawlerScheduleCommand = se_StopCrawlerScheduleCommand;
 const se_StopSessionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StopSession",
-    };
+    const headers = sharedHeaders("StopSession");
     let body;
     body = JSON.stringify(se_StopSessionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopSessionCommand = se_StopSessionCommand;
 const se_StopTriggerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StopTrigger",
-    };
+    const headers = sharedHeaders("StopTrigger");
     let body;
     body = JSON.stringify(se_StopTriggerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopTriggerCommand = se_StopTriggerCommand;
 const se_StopWorkflowRunCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.StopWorkflowRun",
-    };
+    const headers = sharedHeaders("StopWorkflowRun");
     let body;
     body = JSON.stringify(se_StopWorkflowRunRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopWorkflowRunCommand = se_StopWorkflowRunCommand;
 const se_TagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.TagResource",
-    };
+    const headers = sharedHeaders("TagResource");
     let body;
     body = JSON.stringify(se_TagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_TagResourceCommand = se_TagResourceCommand;
 const se_UntagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UntagResource",
-    };
+    const headers = sharedHeaders("UntagResource");
     let body;
     body = JSON.stringify(se_UntagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UntagResourceCommand = se_UntagResourceCommand;
 const se_UpdateBlueprintCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateBlueprint",
-    };
+    const headers = sharedHeaders("UpdateBlueprint");
     let body;
     body = JSON.stringify(se_UpdateBlueprintRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateBlueprintCommand = se_UpdateBlueprintCommand;
 const se_UpdateClassifierCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateClassifier",
-    };
+    const headers = sharedHeaders("UpdateClassifier");
     let body;
     body = JSON.stringify(se_UpdateClassifierRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateClassifierCommand = se_UpdateClassifierCommand;
 const se_UpdateColumnStatisticsForPartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateColumnStatisticsForPartition",
-    };
+    const headers = sharedHeaders("UpdateColumnStatisticsForPartition");
     let body;
     body = JSON.stringify(se_UpdateColumnStatisticsForPartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateColumnStatisticsForPartitionCommand = se_UpdateColumnStatisticsForPartitionCommand;
 const se_UpdateColumnStatisticsForTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateColumnStatisticsForTable",
-    };
+    const headers = sharedHeaders("UpdateColumnStatisticsForTable");
     let body;
     body = JSON.stringify(se_UpdateColumnStatisticsForTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateColumnStatisticsForTableCommand = se_UpdateColumnStatisticsForTableCommand;
 const se_UpdateConnectionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateConnection",
-    };
+    const headers = sharedHeaders("UpdateConnection");
     let body;
     body = JSON.stringify(se_UpdateConnectionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateConnectionCommand = se_UpdateConnectionCommand;
 const se_UpdateCrawlerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateCrawler",
-    };
+    const headers = sharedHeaders("UpdateCrawler");
     let body;
     body = JSON.stringify(se_UpdateCrawlerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateCrawlerCommand = se_UpdateCrawlerCommand;
 const se_UpdateCrawlerScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateCrawlerSchedule",
-    };
+    const headers = sharedHeaders("UpdateCrawlerSchedule");
     let body;
     body = JSON.stringify(se_UpdateCrawlerScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateCrawlerScheduleCommand = se_UpdateCrawlerScheduleCommand;
 const se_UpdateDatabaseCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateDatabase",
-    };
+    const headers = sharedHeaders("UpdateDatabase");
     let body;
     body = JSON.stringify(se_UpdateDatabaseRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDatabaseCommand = se_UpdateDatabaseCommand;
 const se_UpdateDataQualityRulesetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateDataQualityRuleset",
-    };
+    const headers = sharedHeaders("UpdateDataQualityRuleset");
     let body;
     body = JSON.stringify(se_UpdateDataQualityRulesetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDataQualityRulesetCommand = se_UpdateDataQualityRulesetCommand;
 const se_UpdateDevEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateDevEndpoint",
-    };
+    const headers = sharedHeaders("UpdateDevEndpoint");
     let body;
     body = JSON.stringify(se_UpdateDevEndpointRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDevEndpointCommand = se_UpdateDevEndpointCommand;
 const se_UpdateJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateJob",
-    };
+    const headers = sharedHeaders("UpdateJob");
     let body;
     body = JSON.stringify(se_UpdateJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateJobCommand = se_UpdateJobCommand;
 const se_UpdateJobFromSourceControlCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateJobFromSourceControl",
-    };
+    const headers = sharedHeaders("UpdateJobFromSourceControl");
     let body;
     body = JSON.stringify(se_UpdateJobFromSourceControlRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateJobFromSourceControlCommand = se_UpdateJobFromSourceControlCommand;
 const se_UpdateMLTransformCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateMLTransform",
-    };
+    const headers = sharedHeaders("UpdateMLTransform");
     let body;
     body = JSON.stringify(se_UpdateMLTransformRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateMLTransformCommand = se_UpdateMLTransformCommand;
 const se_UpdatePartitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdatePartition",
-    };
+    const headers = sharedHeaders("UpdatePartition");
     let body;
     body = JSON.stringify(se_UpdatePartitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdatePartitionCommand = se_UpdatePartitionCommand;
 const se_UpdateRegistryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateRegistry",
-    };
+    const headers = sharedHeaders("UpdateRegistry");
     let body;
     body = JSON.stringify(se_UpdateRegistryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateRegistryCommand = se_UpdateRegistryCommand;
 const se_UpdateSchemaCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateSchema",
-    };
+    const headers = sharedHeaders("UpdateSchema");
     let body;
     body = JSON.stringify(se_UpdateSchemaInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateSchemaCommand = se_UpdateSchemaCommand;
 const se_UpdateSourceControlFromJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateSourceControlFromJob",
-    };
+    const headers = sharedHeaders("UpdateSourceControlFromJob");
     let body;
     body = JSON.stringify(se_UpdateSourceControlFromJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateSourceControlFromJobCommand = se_UpdateSourceControlFromJobCommand;
 const se_UpdateTableCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateTable",
-    };
+    const headers = sharedHeaders("UpdateTable");
     let body;
     body = JSON.stringify(se_UpdateTableRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateTableCommand = se_UpdateTableCommand;
 const se_UpdateTriggerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateTrigger",
-    };
+    const headers = sharedHeaders("UpdateTrigger");
     let body;
     body = JSON.stringify(se_UpdateTriggerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateTriggerCommand = se_UpdateTriggerCommand;
 const se_UpdateUserDefinedFunctionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateUserDefinedFunction",
-    };
+    const headers = sharedHeaders("UpdateUserDefinedFunction");
     let body;
     body = JSON.stringify(se_UpdateUserDefinedFunctionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateUserDefinedFunctionCommand = se_UpdateUserDefinedFunctionCommand;
 const se_UpdateWorkflowCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSGlue.UpdateWorkflow",
-    };
+    const headers = sharedHeaders("UpdateWorkflow");
     let body;
     body = JSON.stringify(se_UpdateWorkflowRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
@@ -20776,6 +20170,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": `AWSGlue.${operation}`,
+    };
+}
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);