@aws-sdk/client-sagemaker 3.310.0 → 3.312.0

package/dist-cjs/protocols/Aws_json1_1.js

@@ -20,3020 +20,2114 @@ const models_0_1 = require("../models/models_0");
 const models_1_1 = require("../models/models_1");
 const SageMakerServiceException_1 = require("../models/SageMakerServiceException");
 const se_AddAssociationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.AddAssociation",
-    };
+    const headers = sharedHeaders("AddAssociation");
     let body;
     body = JSON.stringify(se_AddAssociationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AddAssociationCommand = se_AddAssociationCommand;
 const se_AddTagsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.AddTags",
-    };
+    const headers = sharedHeaders("AddTags");
     let body;
     body = JSON.stringify(se_AddTagsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AddTagsCommand = se_AddTagsCommand;
 const se_AssociateTrialComponentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.AssociateTrialComponent",
-    };
+    const headers = sharedHeaders("AssociateTrialComponent");
     let body;
     body = JSON.stringify(se_AssociateTrialComponentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AssociateTrialComponentCommand = se_AssociateTrialComponentCommand;
 const se_BatchDescribeModelPackageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.BatchDescribeModelPackage",
-    };
+    const headers = sharedHeaders("BatchDescribeModelPackage");
     let body;
     body = JSON.stringify(se_BatchDescribeModelPackageInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_BatchDescribeModelPackageCommand = se_BatchDescribeModelPackageCommand;
 const se_CreateActionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateAction",
-    };
+    const headers = sharedHeaders("CreateAction");
     let body;
     body = JSON.stringify(se_CreateActionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateActionCommand = se_CreateActionCommand;
 const se_CreateAlgorithmCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateAlgorithm",
-    };
+    const headers = sharedHeaders("CreateAlgorithm");
     let body;
     body = JSON.stringify(se_CreateAlgorithmInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateAlgorithmCommand = se_CreateAlgorithmCommand;
 const se_CreateAppCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateApp",
-    };
+    const headers = sharedHeaders("CreateApp");
     let body;
     body = JSON.stringify(se_CreateAppRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateAppCommand = se_CreateAppCommand;
 const se_CreateAppImageConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateAppImageConfig",
-    };
+    const headers = sharedHeaders("CreateAppImageConfig");
     let body;
     body = JSON.stringify(se_CreateAppImageConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateAppImageConfigCommand = se_CreateAppImageConfigCommand;
 const se_CreateArtifactCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateArtifact",
-    };
+    const headers = sharedHeaders("CreateArtifact");
     let body;
     body = JSON.stringify(se_CreateArtifactRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateArtifactCommand = se_CreateArtifactCommand;
 const se_CreateAutoMLJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateAutoMLJob",
-    };
+    const headers = sharedHeaders("CreateAutoMLJob");
     let body;
     body = JSON.stringify(se_CreateAutoMLJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateAutoMLJobCommand = se_CreateAutoMLJobCommand;
 const se_CreateAutoMLJobV2Command = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateAutoMLJobV2",
-    };
+    const headers = sharedHeaders("CreateAutoMLJobV2");
     let body;
     body = JSON.stringify(se_CreateAutoMLJobV2Request(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateAutoMLJobV2Command = se_CreateAutoMLJobV2Command;
 const se_CreateCodeRepositoryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateCodeRepository",
-    };
+    const headers = sharedHeaders("CreateCodeRepository");
     let body;
     body = JSON.stringify(se_CreateCodeRepositoryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateCodeRepositoryCommand = se_CreateCodeRepositoryCommand;
 const se_CreateCompilationJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateCompilationJob",
-    };
+    const headers = sharedHeaders("CreateCompilationJob");
     let body;
     body = JSON.stringify(se_CreateCompilationJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateCompilationJobCommand = se_CreateCompilationJobCommand;
 const se_CreateContextCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateContext",
-    };
+    const headers = sharedHeaders("CreateContext");
     let body;
     body = JSON.stringify(se_CreateContextRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateContextCommand = se_CreateContextCommand;
 const se_CreateDataQualityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateDataQualityJobDefinition",
-    };
+    const headers = sharedHeaders("CreateDataQualityJobDefinition");
     let body;
     body = JSON.stringify(se_CreateDataQualityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDataQualityJobDefinitionCommand = se_CreateDataQualityJobDefinitionCommand;
 const se_CreateDeviceFleetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateDeviceFleet",
-    };
+    const headers = sharedHeaders("CreateDeviceFleet");
     let body;
     body = JSON.stringify(se_CreateDeviceFleetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDeviceFleetCommand = se_CreateDeviceFleetCommand;
 const se_CreateDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateDomain",
-    };
+    const headers = sharedHeaders("CreateDomain");
     let body;
     body = JSON.stringify(se_CreateDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateDomainCommand = se_CreateDomainCommand;
 const se_CreateEdgeDeploymentPlanCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateEdgeDeploymentPlan",
-    };
+    const headers = sharedHeaders("CreateEdgeDeploymentPlan");
     let body;
     body = JSON.stringify(se_CreateEdgeDeploymentPlanRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateEdgeDeploymentPlanCommand = se_CreateEdgeDeploymentPlanCommand;
 const se_CreateEdgeDeploymentStageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateEdgeDeploymentStage",
-    };
+    const headers = sharedHeaders("CreateEdgeDeploymentStage");
     let body;
     body = JSON.stringify(se_CreateEdgeDeploymentStageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateEdgeDeploymentStageCommand = se_CreateEdgeDeploymentStageCommand;
 const se_CreateEdgePackagingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateEdgePackagingJob",
-    };
+    const headers = sharedHeaders("CreateEdgePackagingJob");
     let body;
     body = JSON.stringify(se_CreateEdgePackagingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateEdgePackagingJobCommand = se_CreateEdgePackagingJobCommand;
 const se_CreateEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateEndpoint",
-    };
+    const headers = sharedHeaders("CreateEndpoint");
     let body;
     body = JSON.stringify(se_CreateEndpointInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateEndpointCommand = se_CreateEndpointCommand;
 const se_CreateEndpointConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateEndpointConfig",
-    };
+    const headers = sharedHeaders("CreateEndpointConfig");
     let body;
     body = JSON.stringify(se_CreateEndpointConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateEndpointConfigCommand = se_CreateEndpointConfigCommand;
 const se_CreateExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateExperiment",
-    };
+    const headers = sharedHeaders("CreateExperiment");
     let body;
     body = JSON.stringify(se_CreateExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateExperimentCommand = se_CreateExperimentCommand;
 const se_CreateFeatureGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateFeatureGroup",
-    };
+    const headers = sharedHeaders("CreateFeatureGroup");
     let body;
     body = JSON.stringify(se_CreateFeatureGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateFeatureGroupCommand = se_CreateFeatureGroupCommand;
 const se_CreateFlowDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateFlowDefinition",
-    };
+    const headers = sharedHeaders("CreateFlowDefinition");
     let body;
     body = JSON.stringify(se_CreateFlowDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateFlowDefinitionCommand = se_CreateFlowDefinitionCommand;
 const se_CreateHubCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateHub",
-    };
+    const headers = sharedHeaders("CreateHub");
     let body;
     body = JSON.stringify(se_CreateHubRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateHubCommand = se_CreateHubCommand;
 const se_CreateHumanTaskUiCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateHumanTaskUi",
-    };
+    const headers = sharedHeaders("CreateHumanTaskUi");
     let body;
     body = JSON.stringify(se_CreateHumanTaskUiRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateHumanTaskUiCommand = se_CreateHumanTaskUiCommand;
 const se_CreateHyperParameterTuningJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateHyperParameterTuningJob",
-    };
+    const headers = sharedHeaders("CreateHyperParameterTuningJob");
     let body;
     body = JSON.stringify(se_CreateHyperParameterTuningJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateHyperParameterTuningJobCommand = se_CreateHyperParameterTuningJobCommand;
 const se_CreateImageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateImage",
-    };
+    const headers = sharedHeaders("CreateImage");
     let body;
     body = JSON.stringify(se_CreateImageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateImageCommand = se_CreateImageCommand;
 const se_CreateImageVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateImageVersion",
-    };
+    const headers = sharedHeaders("CreateImageVersion");
     let body;
     body = JSON.stringify(se_CreateImageVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateImageVersionCommand = se_CreateImageVersionCommand;
 const se_CreateInferenceExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateInferenceExperiment",
-    };
+    const headers = sharedHeaders("CreateInferenceExperiment");
     let body;
     body = JSON.stringify(se_CreateInferenceExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateInferenceExperimentCommand = se_CreateInferenceExperimentCommand;
 const se_CreateInferenceRecommendationsJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateInferenceRecommendationsJob",
-    };
+    const headers = sharedHeaders("CreateInferenceRecommendationsJob");
     let body;
     body = JSON.stringify(se_CreateInferenceRecommendationsJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateInferenceRecommendationsJobCommand = se_CreateInferenceRecommendationsJobCommand;
 const se_CreateLabelingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateLabelingJob",
-    };
+    const headers = sharedHeaders("CreateLabelingJob");
     let body;
     body = JSON.stringify(se_CreateLabelingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateLabelingJobCommand = se_CreateLabelingJobCommand;
 const se_CreateModelCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModel",
-    };
+    const headers = sharedHeaders("CreateModel");
     let body;
     body = JSON.stringify(se_CreateModelInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelCommand = se_CreateModelCommand;
 const se_CreateModelBiasJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelBiasJobDefinition",
-    };
+    const headers = sharedHeaders("CreateModelBiasJobDefinition");
     let body;
     body = JSON.stringify(se_CreateModelBiasJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelBiasJobDefinitionCommand = se_CreateModelBiasJobDefinitionCommand;
 const se_CreateModelCardCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelCard",
-    };
+    const headers = sharedHeaders("CreateModelCard");
     let body;
     body = JSON.stringify(se_CreateModelCardRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelCardCommand = se_CreateModelCardCommand;
 const se_CreateModelCardExportJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelCardExportJob",
-    };
+    const headers = sharedHeaders("CreateModelCardExportJob");
     let body;
     body = JSON.stringify(se_CreateModelCardExportJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelCardExportJobCommand = se_CreateModelCardExportJobCommand;
 const se_CreateModelExplainabilityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelExplainabilityJobDefinition",
-    };
+    const headers = sharedHeaders("CreateModelExplainabilityJobDefinition");
     let body;
     body = JSON.stringify(se_CreateModelExplainabilityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelExplainabilityJobDefinitionCommand = se_CreateModelExplainabilityJobDefinitionCommand;
 const se_CreateModelPackageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelPackage",
-    };
+    const headers = sharedHeaders("CreateModelPackage");
     let body;
     body = JSON.stringify(se_CreateModelPackageInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelPackageCommand = se_CreateModelPackageCommand;
 const se_CreateModelPackageGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelPackageGroup",
-    };
+    const headers = sharedHeaders("CreateModelPackageGroup");
     let body;
     body = JSON.stringify(se_CreateModelPackageGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelPackageGroupCommand = se_CreateModelPackageGroupCommand;
 const se_CreateModelQualityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateModelQualityJobDefinition",
-    };
+    const headers = sharedHeaders("CreateModelQualityJobDefinition");
     let body;
     body = JSON.stringify(se_CreateModelQualityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateModelQualityJobDefinitionCommand = se_CreateModelQualityJobDefinitionCommand;
 const se_CreateMonitoringScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateMonitoringSchedule",
-    };
+    const headers = sharedHeaders("CreateMonitoringSchedule");
     let body;
     body = JSON.stringify(se_CreateMonitoringScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateMonitoringScheduleCommand = se_CreateMonitoringScheduleCommand;
 const se_CreateNotebookInstanceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateNotebookInstance",
-    };
+    const headers = sharedHeaders("CreateNotebookInstance");
     let body;
     body = JSON.stringify(se_CreateNotebookInstanceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateNotebookInstanceCommand = se_CreateNotebookInstanceCommand;
 const se_CreateNotebookInstanceLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateNotebookInstanceLifecycleConfig",
-    };
+    const headers = sharedHeaders("CreateNotebookInstanceLifecycleConfig");
     let body;
     body = JSON.stringify(se_CreateNotebookInstanceLifecycleConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateNotebookInstanceLifecycleConfigCommand = se_CreateNotebookInstanceLifecycleConfigCommand;
 const se_CreatePipelineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreatePipeline",
-    };
+    const headers = sharedHeaders("CreatePipeline");
     let body;
     body = JSON.stringify(se_CreatePipelineRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePipelineCommand = se_CreatePipelineCommand;
 const se_CreatePresignedDomainUrlCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreatePresignedDomainUrl",
-    };
+    const headers = sharedHeaders("CreatePresignedDomainUrl");
     let body;
     body = JSON.stringify(se_CreatePresignedDomainUrlRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePresignedDomainUrlCommand = se_CreatePresignedDomainUrlCommand;
 const se_CreatePresignedNotebookInstanceUrlCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreatePresignedNotebookInstanceUrl",
-    };
+    const headers = sharedHeaders("CreatePresignedNotebookInstanceUrl");
     let body;
     body = JSON.stringify(se_CreatePresignedNotebookInstanceUrlInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreatePresignedNotebookInstanceUrlCommand = se_CreatePresignedNotebookInstanceUrlCommand;
 const se_CreateProcessingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateProcessingJob",
-    };
+    const headers = sharedHeaders("CreateProcessingJob");
     let body;
     body = JSON.stringify(se_CreateProcessingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateProcessingJobCommand = se_CreateProcessingJobCommand;
 const se_CreateProjectCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateProject",
-    };
+    const headers = sharedHeaders("CreateProject");
     let body;
     body = JSON.stringify(se_CreateProjectInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateProjectCommand = se_CreateProjectCommand;
 const se_CreateSpaceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateSpace",
-    };
+    const headers = sharedHeaders("CreateSpace");
     let body;
     body = JSON.stringify(se_CreateSpaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateSpaceCommand = se_CreateSpaceCommand;
 const se_CreateStudioLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateStudioLifecycleConfig",
-    };
+    const headers = sharedHeaders("CreateStudioLifecycleConfig");
     let body;
     body = JSON.stringify(se_CreateStudioLifecycleConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateStudioLifecycleConfigCommand = se_CreateStudioLifecycleConfigCommand;
 const se_CreateTrainingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateTrainingJob",
-    };
+    const headers = sharedHeaders("CreateTrainingJob");
     let body;
     body = JSON.stringify(se_CreateTrainingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateTrainingJobCommand = se_CreateTrainingJobCommand;
 const se_CreateTransformJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateTransformJob",
-    };
+    const headers = sharedHeaders("CreateTransformJob");
     let body;
     body = JSON.stringify(se_CreateTransformJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateTransformJobCommand = se_CreateTransformJobCommand;
 const se_CreateTrialCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateTrial",
-    };
+    const headers = sharedHeaders("CreateTrial");
     let body;
     body = JSON.stringify(se_CreateTrialRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateTrialCommand = se_CreateTrialCommand;
 const se_CreateTrialComponentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateTrialComponent",
-    };
+    const headers = sharedHeaders("CreateTrialComponent");
     let body;
     body = JSON.stringify(se_CreateTrialComponentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateTrialComponentCommand = se_CreateTrialComponentCommand;
 const se_CreateUserProfileCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateUserProfile",
-    };
+    const headers = sharedHeaders("CreateUserProfile");
     let body;
     body = JSON.stringify(se_CreateUserProfileRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateUserProfileCommand = se_CreateUserProfileCommand;
 const se_CreateWorkforceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateWorkforce",
-    };
+    const headers = sharedHeaders("CreateWorkforce");
     let body;
     body = JSON.stringify(se_CreateWorkforceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateWorkforceCommand = se_CreateWorkforceCommand;
 const se_CreateWorkteamCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.CreateWorkteam",
-    };
+    const headers = sharedHeaders("CreateWorkteam");
     let body;
     body = JSON.stringify(se_CreateWorkteamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateWorkteamCommand = se_CreateWorkteamCommand;
 const se_DeleteActionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteAction",
-    };
+    const headers = sharedHeaders("DeleteAction");
     let body;
     body = JSON.stringify(se_DeleteActionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteActionCommand = se_DeleteActionCommand;
 const se_DeleteAlgorithmCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteAlgorithm",
-    };
+    const headers = sharedHeaders("DeleteAlgorithm");
     let body;
     body = JSON.stringify(se_DeleteAlgorithmInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteAlgorithmCommand = se_DeleteAlgorithmCommand;
 const se_DeleteAppCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteApp",
-    };
+    const headers = sharedHeaders("DeleteApp");
     let body;
     body = JSON.stringify(se_DeleteAppRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteAppCommand = se_DeleteAppCommand;
 const se_DeleteAppImageConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteAppImageConfig",
-    };
+    const headers = sharedHeaders("DeleteAppImageConfig");
     let body;
     body = JSON.stringify(se_DeleteAppImageConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteAppImageConfigCommand = se_DeleteAppImageConfigCommand;
 const se_DeleteArtifactCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteArtifact",
-    };
+    const headers = sharedHeaders("DeleteArtifact");
     let body;
     body = JSON.stringify(se_DeleteArtifactRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteArtifactCommand = se_DeleteArtifactCommand;
 const se_DeleteAssociationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteAssociation",
-    };
+    const headers = sharedHeaders("DeleteAssociation");
     let body;
     body = JSON.stringify(se_DeleteAssociationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteAssociationCommand = se_DeleteAssociationCommand;
 const se_DeleteCodeRepositoryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteCodeRepository",
-    };
+    const headers = sharedHeaders("DeleteCodeRepository");
     let body;
     body = JSON.stringify(se_DeleteCodeRepositoryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteCodeRepositoryCommand = se_DeleteCodeRepositoryCommand;
 const se_DeleteContextCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteContext",
-    };
+    const headers = sharedHeaders("DeleteContext");
     let body;
     body = JSON.stringify(se_DeleteContextRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteContextCommand = se_DeleteContextCommand;
 const se_DeleteDataQualityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteDataQualityJobDefinition",
-    };
+    const headers = sharedHeaders("DeleteDataQualityJobDefinition");
     let body;
     body = JSON.stringify(se_DeleteDataQualityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDataQualityJobDefinitionCommand = se_DeleteDataQualityJobDefinitionCommand;
 const se_DeleteDeviceFleetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteDeviceFleet",
-    };
+    const headers = sharedHeaders("DeleteDeviceFleet");
     let body;
     body = JSON.stringify(se_DeleteDeviceFleetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDeviceFleetCommand = se_DeleteDeviceFleetCommand;
 const se_DeleteDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteDomain",
-    };
+    const headers = sharedHeaders("DeleteDomain");
     let body;
     body = JSON.stringify(se_DeleteDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteDomainCommand = se_DeleteDomainCommand;
 const se_DeleteEdgeDeploymentPlanCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteEdgeDeploymentPlan",
-    };
+    const headers = sharedHeaders("DeleteEdgeDeploymentPlan");
     let body;
     body = JSON.stringify(se_DeleteEdgeDeploymentPlanRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteEdgeDeploymentPlanCommand = se_DeleteEdgeDeploymentPlanCommand;
 const se_DeleteEdgeDeploymentStageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteEdgeDeploymentStage",
-    };
+    const headers = sharedHeaders("DeleteEdgeDeploymentStage");
     let body;
     body = JSON.stringify(se_DeleteEdgeDeploymentStageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteEdgeDeploymentStageCommand = se_DeleteEdgeDeploymentStageCommand;
 const se_DeleteEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteEndpoint",
-    };
+    const headers = sharedHeaders("DeleteEndpoint");
     let body;
     body = JSON.stringify(se_DeleteEndpointInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteEndpointCommand = se_DeleteEndpointCommand;
 const se_DeleteEndpointConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteEndpointConfig",
-    };
+    const headers = sharedHeaders("DeleteEndpointConfig");
     let body;
     body = JSON.stringify(se_DeleteEndpointConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteEndpointConfigCommand = se_DeleteEndpointConfigCommand;
 const se_DeleteExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteExperiment",
-    };
+    const headers = sharedHeaders("DeleteExperiment");
     let body;
     body = JSON.stringify(se_DeleteExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteExperimentCommand = se_DeleteExperimentCommand;
 const se_DeleteFeatureGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteFeatureGroup",
-    };
+    const headers = sharedHeaders("DeleteFeatureGroup");
     let body;
     body = JSON.stringify(se_DeleteFeatureGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteFeatureGroupCommand = se_DeleteFeatureGroupCommand;
 const se_DeleteFlowDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteFlowDefinition",
-    };
+    const headers = sharedHeaders("DeleteFlowDefinition");
     let body;
     body = JSON.stringify(se_DeleteFlowDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteFlowDefinitionCommand = se_DeleteFlowDefinitionCommand;
 const se_DeleteHubCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteHub",
-    };
+    const headers = sharedHeaders("DeleteHub");
     let body;
     body = JSON.stringify(se_DeleteHubRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteHubCommand = se_DeleteHubCommand;
 const se_DeleteHubContentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteHubContent",
-    };
+    const headers = sharedHeaders("DeleteHubContent");
     let body;
     body = JSON.stringify(se_DeleteHubContentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteHubContentCommand = se_DeleteHubContentCommand;
 const se_DeleteHumanTaskUiCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteHumanTaskUi",
-    };
+    const headers = sharedHeaders("DeleteHumanTaskUi");
     let body;
     body = JSON.stringify(se_DeleteHumanTaskUiRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteHumanTaskUiCommand = se_DeleteHumanTaskUiCommand;
 const se_DeleteImageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteImage",
-    };
+    const headers = sharedHeaders("DeleteImage");
     let body;
     body = JSON.stringify(se_DeleteImageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteImageCommand = se_DeleteImageCommand;
 const se_DeleteImageVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteImageVersion",
-    };
+    const headers = sharedHeaders("DeleteImageVersion");
     let body;
     body = JSON.stringify(se_DeleteImageVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteImageVersionCommand = se_DeleteImageVersionCommand;
 const se_DeleteInferenceExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteInferenceExperiment",
-    };
+    const headers = sharedHeaders("DeleteInferenceExperiment");
     let body;
     body = JSON.stringify(se_DeleteInferenceExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteInferenceExperimentCommand = se_DeleteInferenceExperimentCommand;
 const se_DeleteModelCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModel",
-    };
+    const headers = sharedHeaders("DeleteModel");
     let body;
     body = JSON.stringify(se_DeleteModelInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelCommand = se_DeleteModelCommand;
 const se_DeleteModelBiasJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelBiasJobDefinition",
-    };
+    const headers = sharedHeaders("DeleteModelBiasJobDefinition");
     let body;
     body = JSON.stringify(se_DeleteModelBiasJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelBiasJobDefinitionCommand = se_DeleteModelBiasJobDefinitionCommand;
 const se_DeleteModelCardCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelCard",
-    };
+    const headers = sharedHeaders("DeleteModelCard");
     let body;
     body = JSON.stringify(se_DeleteModelCardRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelCardCommand = se_DeleteModelCardCommand;
 const se_DeleteModelExplainabilityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelExplainabilityJobDefinition",
-    };
+    const headers = sharedHeaders("DeleteModelExplainabilityJobDefinition");
     let body;
     body = JSON.stringify(se_DeleteModelExplainabilityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelExplainabilityJobDefinitionCommand = se_DeleteModelExplainabilityJobDefinitionCommand;
 const se_DeleteModelPackageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelPackage",
-    };
+    const headers = sharedHeaders("DeleteModelPackage");
     let body;
     body = JSON.stringify(se_DeleteModelPackageInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelPackageCommand = se_DeleteModelPackageCommand;
 const se_DeleteModelPackageGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelPackageGroup",
-    };
+    const headers = sharedHeaders("DeleteModelPackageGroup");
     let body;
     body = JSON.stringify(se_DeleteModelPackageGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelPackageGroupCommand = se_DeleteModelPackageGroupCommand;
 const se_DeleteModelPackageGroupPolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelPackageGroupPolicy",
-    };
+    const headers = sharedHeaders("DeleteModelPackageGroupPolicy");
     let body;
     body = JSON.stringify(se_DeleteModelPackageGroupPolicyInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelPackageGroupPolicyCommand = se_DeleteModelPackageGroupPolicyCommand;
 const se_DeleteModelQualityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteModelQualityJobDefinition",
-    };
+    const headers = sharedHeaders("DeleteModelQualityJobDefinition");
     let body;
     body = JSON.stringify(se_DeleteModelQualityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteModelQualityJobDefinitionCommand = se_DeleteModelQualityJobDefinitionCommand;
 const se_DeleteMonitoringScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteMonitoringSchedule",
-    };
+    const headers = sharedHeaders("DeleteMonitoringSchedule");
     let body;
     body = JSON.stringify(se_DeleteMonitoringScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteMonitoringScheduleCommand = se_DeleteMonitoringScheduleCommand;
 const se_DeleteNotebookInstanceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteNotebookInstance",
-    };
+    const headers = sharedHeaders("DeleteNotebookInstance");
     let body;
     body = JSON.stringify(se_DeleteNotebookInstanceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteNotebookInstanceCommand = se_DeleteNotebookInstanceCommand;
 const se_DeleteNotebookInstanceLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteNotebookInstanceLifecycleConfig",
-    };
+    const headers = sharedHeaders("DeleteNotebookInstanceLifecycleConfig");
     let body;
     body = JSON.stringify(se_DeleteNotebookInstanceLifecycleConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteNotebookInstanceLifecycleConfigCommand = se_DeleteNotebookInstanceLifecycleConfigCommand;
 const se_DeletePipelineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeletePipeline",
-    };
+    const headers = sharedHeaders("DeletePipeline");
     let body;
     body = JSON.stringify(se_DeletePipelineRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeletePipelineCommand = se_DeletePipelineCommand;
 const se_DeleteProjectCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteProject",
-    };
+    const headers = sharedHeaders("DeleteProject");
     let body;
     body = JSON.stringify(se_DeleteProjectInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteProjectCommand = se_DeleteProjectCommand;
 const se_DeleteSpaceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteSpace",
-    };
+    const headers = sharedHeaders("DeleteSpace");
     let body;
     body = JSON.stringify(se_DeleteSpaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteSpaceCommand = se_DeleteSpaceCommand;
 const se_DeleteStudioLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteStudioLifecycleConfig",
-    };
+    const headers = sharedHeaders("DeleteStudioLifecycleConfig");
     let body;
     body = JSON.stringify(se_DeleteStudioLifecycleConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteStudioLifecycleConfigCommand = se_DeleteStudioLifecycleConfigCommand;
 const se_DeleteTagsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteTags",
-    };
+    const headers = sharedHeaders("DeleteTags");
     let body;
     body = JSON.stringify(se_DeleteTagsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteTagsCommand = se_DeleteTagsCommand;
 const se_DeleteTrialCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteTrial",
-    };
+    const headers = sharedHeaders("DeleteTrial");
     let body;
     body = JSON.stringify(se_DeleteTrialRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteTrialCommand = se_DeleteTrialCommand;
 const se_DeleteTrialComponentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteTrialComponent",
-    };
+    const headers = sharedHeaders("DeleteTrialComponent");
     let body;
     body = JSON.stringify(se_DeleteTrialComponentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteTrialComponentCommand = se_DeleteTrialComponentCommand;
 const se_DeleteUserProfileCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteUserProfile",
-    };
+    const headers = sharedHeaders("DeleteUserProfile");
     let body;
     body = JSON.stringify(se_DeleteUserProfileRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserProfileCommand = se_DeleteUserProfileCommand;
 const se_DeleteWorkforceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteWorkforce",
-    };
+    const headers = sharedHeaders("DeleteWorkforce");
     let body;
     body = JSON.stringify(se_DeleteWorkforceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteWorkforceCommand = se_DeleteWorkforceCommand;
 const se_DeleteWorkteamCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeleteWorkteam",
-    };
+    const headers = sharedHeaders("DeleteWorkteam");
     let body;
     body = JSON.stringify(se_DeleteWorkteamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteWorkteamCommand = se_DeleteWorkteamCommand;
 const se_DeregisterDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DeregisterDevices",
-    };
+    const headers = sharedHeaders("DeregisterDevices");
     let body;
     body = JSON.stringify(se_DeregisterDevicesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeregisterDevicesCommand = se_DeregisterDevicesCommand;
 const se_DescribeActionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeAction",
-    };
+    const headers = sharedHeaders("DescribeAction");
     let body;
     body = JSON.stringify(se_DescribeActionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeActionCommand = se_DescribeActionCommand;
 const se_DescribeAlgorithmCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeAlgorithm",
-    };
+    const headers = sharedHeaders("DescribeAlgorithm");
     let body;
     body = JSON.stringify(se_DescribeAlgorithmInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeAlgorithmCommand = se_DescribeAlgorithmCommand;
 const se_DescribeAppCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeApp",
-    };
+    const headers = sharedHeaders("DescribeApp");
     let body;
     body = JSON.stringify(se_DescribeAppRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeAppCommand = se_DescribeAppCommand;
 const se_DescribeAppImageConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeAppImageConfig",
-    };
+    const headers = sharedHeaders("DescribeAppImageConfig");
     let body;
     body = JSON.stringify(se_DescribeAppImageConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeAppImageConfigCommand = se_DescribeAppImageConfigCommand;
 const se_DescribeArtifactCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeArtifact",
-    };
+    const headers = sharedHeaders("DescribeArtifact");
     let body;
     body = JSON.stringify(se_DescribeArtifactRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeArtifactCommand = se_DescribeArtifactCommand;
 const se_DescribeAutoMLJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeAutoMLJob",
-    };
+    const headers = sharedHeaders("DescribeAutoMLJob");
     let body;
     body = JSON.stringify(se_DescribeAutoMLJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeAutoMLJobCommand = se_DescribeAutoMLJobCommand;
 const se_DescribeAutoMLJobV2Command = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeAutoMLJobV2",
-    };
+    const headers = sharedHeaders("DescribeAutoMLJobV2");
     let body;
     body = JSON.stringify(se_DescribeAutoMLJobV2Request(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeAutoMLJobV2Command = se_DescribeAutoMLJobV2Command;
 const se_DescribeCodeRepositoryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeCodeRepository",
-    };
+    const headers = sharedHeaders("DescribeCodeRepository");
     let body;
     body = JSON.stringify(se_DescribeCodeRepositoryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeCodeRepositoryCommand = se_DescribeCodeRepositoryCommand;
 const se_DescribeCompilationJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeCompilationJob",
-    };
+    const headers = sharedHeaders("DescribeCompilationJob");
     let body;
     body = JSON.stringify(se_DescribeCompilationJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeCompilationJobCommand = se_DescribeCompilationJobCommand;
 const se_DescribeContextCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeContext",
-    };
+    const headers = sharedHeaders("DescribeContext");
     let body;
     body = JSON.stringify(se_DescribeContextRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeContextCommand = se_DescribeContextCommand;
 const se_DescribeDataQualityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeDataQualityJobDefinition",
-    };
+    const headers = sharedHeaders("DescribeDataQualityJobDefinition");
     let body;
     body = JSON.stringify(se_DescribeDataQualityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeDataQualityJobDefinitionCommand = se_DescribeDataQualityJobDefinitionCommand;
 const se_DescribeDeviceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeDevice",
-    };
+    const headers = sharedHeaders("DescribeDevice");
     let body;
     body = JSON.stringify(se_DescribeDeviceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeDeviceCommand = se_DescribeDeviceCommand;
 const se_DescribeDeviceFleetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeDeviceFleet",
-    };
+    const headers = sharedHeaders("DescribeDeviceFleet");
     let body;
     body = JSON.stringify(se_DescribeDeviceFleetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeDeviceFleetCommand = se_DescribeDeviceFleetCommand;
 const se_DescribeDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeDomain",
-    };
+    const headers = sharedHeaders("DescribeDomain");
     let body;
     body = JSON.stringify(se_DescribeDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeDomainCommand = se_DescribeDomainCommand;
 const se_DescribeEdgeDeploymentPlanCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeEdgeDeploymentPlan",
-    };
+    const headers = sharedHeaders("DescribeEdgeDeploymentPlan");
     let body;
     body = JSON.stringify(se_DescribeEdgeDeploymentPlanRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeEdgeDeploymentPlanCommand = se_DescribeEdgeDeploymentPlanCommand;
 const se_DescribeEdgePackagingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeEdgePackagingJob",
-    };
+    const headers = sharedHeaders("DescribeEdgePackagingJob");
     let body;
     body = JSON.stringify(se_DescribeEdgePackagingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeEdgePackagingJobCommand = se_DescribeEdgePackagingJobCommand;
 const se_DescribeEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeEndpoint",
-    };
+    const headers = sharedHeaders("DescribeEndpoint");
     let body;
     body = JSON.stringify(se_DescribeEndpointInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeEndpointCommand = se_DescribeEndpointCommand;
 const se_DescribeEndpointConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeEndpointConfig",
-    };
+    const headers = sharedHeaders("DescribeEndpointConfig");
     let body;
     body = JSON.stringify(se_DescribeEndpointConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeEndpointConfigCommand = se_DescribeEndpointConfigCommand;
 const se_DescribeExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeExperiment",
-    };
+    const headers = sharedHeaders("DescribeExperiment");
     let body;
     body = JSON.stringify(se_DescribeExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeExperimentCommand = se_DescribeExperimentCommand;
 const se_DescribeFeatureGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeFeatureGroup",
-    };
+    const headers = sharedHeaders("DescribeFeatureGroup");
     let body;
     body = JSON.stringify(se_DescribeFeatureGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeFeatureGroupCommand = se_DescribeFeatureGroupCommand;
 const se_DescribeFeatureMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeFeatureMetadata",
-    };
+    const headers = sharedHeaders("DescribeFeatureMetadata");
     let body;
     body = JSON.stringify(se_DescribeFeatureMetadataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeFeatureMetadataCommand = se_DescribeFeatureMetadataCommand;
 const se_DescribeFlowDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeFlowDefinition",
-    };
+    const headers = sharedHeaders("DescribeFlowDefinition");
     let body;
     body = JSON.stringify(se_DescribeFlowDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeFlowDefinitionCommand = se_DescribeFlowDefinitionCommand;
 const se_DescribeHubCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeHub",
-    };
+    const headers = sharedHeaders("DescribeHub");
     let body;
     body = JSON.stringify(se_DescribeHubRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeHubCommand = se_DescribeHubCommand;
 const se_DescribeHubContentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeHubContent",
-    };
+    const headers = sharedHeaders("DescribeHubContent");
     let body;
     body = JSON.stringify(se_DescribeHubContentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeHubContentCommand = se_DescribeHubContentCommand;
 const se_DescribeHumanTaskUiCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeHumanTaskUi",
-    };
+    const headers = sharedHeaders("DescribeHumanTaskUi");
     let body;
     body = JSON.stringify(se_DescribeHumanTaskUiRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeHumanTaskUiCommand = se_DescribeHumanTaskUiCommand;
 const se_DescribeHyperParameterTuningJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeHyperParameterTuningJob",
-    };
+    const headers = sharedHeaders("DescribeHyperParameterTuningJob");
     let body;
     body = JSON.stringify(se_DescribeHyperParameterTuningJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeHyperParameterTuningJobCommand = se_DescribeHyperParameterTuningJobCommand;
 const se_DescribeImageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeImage",
-    };
+    const headers = sharedHeaders("DescribeImage");
     let body;
     body = JSON.stringify(se_DescribeImageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeImageCommand = se_DescribeImageCommand;
 const se_DescribeImageVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeImageVersion",
-    };
+    const headers = sharedHeaders("DescribeImageVersion");
     let body;
     body = JSON.stringify(se_DescribeImageVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeImageVersionCommand = se_DescribeImageVersionCommand;
 const se_DescribeInferenceExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeInferenceExperiment",
-    };
+    const headers = sharedHeaders("DescribeInferenceExperiment");
     let body;
     body = JSON.stringify(se_DescribeInferenceExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeInferenceExperimentCommand = se_DescribeInferenceExperimentCommand;
 const se_DescribeInferenceRecommendationsJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeInferenceRecommendationsJob",
-    };
+    const headers = sharedHeaders("DescribeInferenceRecommendationsJob");
     let body;
     body = JSON.stringify(se_DescribeInferenceRecommendationsJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeInferenceRecommendationsJobCommand = se_DescribeInferenceRecommendationsJobCommand;
 const se_DescribeLabelingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeLabelingJob",
-    };
+    const headers = sharedHeaders("DescribeLabelingJob");
     let body;
     body = JSON.stringify(se_DescribeLabelingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeLabelingJobCommand = se_DescribeLabelingJobCommand;
 const se_DescribeLineageGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeLineageGroup",
-    };
+    const headers = sharedHeaders("DescribeLineageGroup");
     let body;
     body = JSON.stringify(se_DescribeLineageGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeLineageGroupCommand = se_DescribeLineageGroupCommand;
 const se_DescribeModelCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModel",
-    };
+    const headers = sharedHeaders("DescribeModel");
     let body;
     body = JSON.stringify(se_DescribeModelInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelCommand = se_DescribeModelCommand;
 const se_DescribeModelBiasJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelBiasJobDefinition",
-    };
+    const headers = sharedHeaders("DescribeModelBiasJobDefinition");
     let body;
     body = JSON.stringify(se_DescribeModelBiasJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelBiasJobDefinitionCommand = se_DescribeModelBiasJobDefinitionCommand;
 const se_DescribeModelCardCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelCard",
-    };
+    const headers = sharedHeaders("DescribeModelCard");
     let body;
     body = JSON.stringify(se_DescribeModelCardRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelCardCommand = se_DescribeModelCardCommand;
 const se_DescribeModelCardExportJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelCardExportJob",
-    };
+    const headers = sharedHeaders("DescribeModelCardExportJob");
     let body;
     body = JSON.stringify(se_DescribeModelCardExportJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelCardExportJobCommand = se_DescribeModelCardExportJobCommand;
 const se_DescribeModelExplainabilityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelExplainabilityJobDefinition",
-    };
+    const headers = sharedHeaders("DescribeModelExplainabilityJobDefinition");
     let body;
     body = JSON.stringify(se_DescribeModelExplainabilityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelExplainabilityJobDefinitionCommand = se_DescribeModelExplainabilityJobDefinitionCommand;
 const se_DescribeModelPackageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelPackage",
-    };
+    const headers = sharedHeaders("DescribeModelPackage");
     let body;
     body = JSON.stringify(se_DescribeModelPackageInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelPackageCommand = se_DescribeModelPackageCommand;
 const se_DescribeModelPackageGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelPackageGroup",
-    };
+    const headers = sharedHeaders("DescribeModelPackageGroup");
     let body;
     body = JSON.stringify(se_DescribeModelPackageGroupInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelPackageGroupCommand = se_DescribeModelPackageGroupCommand;
 const se_DescribeModelQualityJobDefinitionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeModelQualityJobDefinition",
-    };
+    const headers = sharedHeaders("DescribeModelQualityJobDefinition");
     let body;
     body = JSON.stringify(se_DescribeModelQualityJobDefinitionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeModelQualityJobDefinitionCommand = se_DescribeModelQualityJobDefinitionCommand;
 const se_DescribeMonitoringScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeMonitoringSchedule",
-    };
+    const headers = sharedHeaders("DescribeMonitoringSchedule");
     let body;
     body = JSON.stringify(se_DescribeMonitoringScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeMonitoringScheduleCommand = se_DescribeMonitoringScheduleCommand;
 const se_DescribeNotebookInstanceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeNotebookInstance",
-    };
+    const headers = sharedHeaders("DescribeNotebookInstance");
     let body;
     body = JSON.stringify(se_DescribeNotebookInstanceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeNotebookInstanceCommand = se_DescribeNotebookInstanceCommand;
 const se_DescribeNotebookInstanceLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeNotebookInstanceLifecycleConfig",
-    };
+    const headers = sharedHeaders("DescribeNotebookInstanceLifecycleConfig");
     let body;
     body = JSON.stringify(se_DescribeNotebookInstanceLifecycleConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeNotebookInstanceLifecycleConfigCommand = se_DescribeNotebookInstanceLifecycleConfigCommand;
 const se_DescribePipelineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribePipeline",
-    };
+    const headers = sharedHeaders("DescribePipeline");
     let body;
     body = JSON.stringify(se_DescribePipelineRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribePipelineCommand = se_DescribePipelineCommand;
 const se_DescribePipelineDefinitionForExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribePipelineDefinitionForExecution",
-    };
+    const headers = sharedHeaders("DescribePipelineDefinitionForExecution");
     let body;
     body = JSON.stringify(se_DescribePipelineDefinitionForExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribePipelineDefinitionForExecutionCommand = se_DescribePipelineDefinitionForExecutionCommand;
 const se_DescribePipelineExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribePipelineExecution",
-    };
+    const headers = sharedHeaders("DescribePipelineExecution");
     let body;
     body = JSON.stringify(se_DescribePipelineExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribePipelineExecutionCommand = se_DescribePipelineExecutionCommand;
 const se_DescribeProcessingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeProcessingJob",
-    };
+    const headers = sharedHeaders("DescribeProcessingJob");
     let body;
     body = JSON.stringify(se_DescribeProcessingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeProcessingJobCommand = se_DescribeProcessingJobCommand;
 const se_DescribeProjectCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeProject",
-    };
+    const headers = sharedHeaders("DescribeProject");
     let body;
     body = JSON.stringify(se_DescribeProjectInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeProjectCommand = se_DescribeProjectCommand;
 const se_DescribeSpaceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeSpace",
-    };
+    const headers = sharedHeaders("DescribeSpace");
     let body;
     body = JSON.stringify(se_DescribeSpaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeSpaceCommand = se_DescribeSpaceCommand;
 const se_DescribeStudioLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeStudioLifecycleConfig",
-    };
+    const headers = sharedHeaders("DescribeStudioLifecycleConfig");
     let body;
     body = JSON.stringify(se_DescribeStudioLifecycleConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeStudioLifecycleConfigCommand = se_DescribeStudioLifecycleConfigCommand;
 const se_DescribeSubscribedWorkteamCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeSubscribedWorkteam",
-    };
+    const headers = sharedHeaders("DescribeSubscribedWorkteam");
     let body;
     body = JSON.stringify(se_DescribeSubscribedWorkteamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeSubscribedWorkteamCommand = se_DescribeSubscribedWorkteamCommand;
 const se_DescribeTrainingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeTrainingJob",
-    };
+    const headers = sharedHeaders("DescribeTrainingJob");
     let body;
     body = JSON.stringify(se_DescribeTrainingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeTrainingJobCommand = se_DescribeTrainingJobCommand;
 const se_DescribeTransformJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeTransformJob",
-    };
+    const headers = sharedHeaders("DescribeTransformJob");
     let body;
     body = JSON.stringify(se_DescribeTransformJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeTransformJobCommand = se_DescribeTransformJobCommand;
 const se_DescribeTrialCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeTrial",
-    };
+    const headers = sharedHeaders("DescribeTrial");
     let body;
     body = JSON.stringify(se_DescribeTrialRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeTrialCommand = se_DescribeTrialCommand;
 const se_DescribeTrialComponentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeTrialComponent",
-    };
+    const headers = sharedHeaders("DescribeTrialComponent");
     let body;
     body = JSON.stringify(se_DescribeTrialComponentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeTrialComponentCommand = se_DescribeTrialComponentCommand;
 const se_DescribeUserProfileCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeUserProfile",
-    };
+    const headers = sharedHeaders("DescribeUserProfile");
     let body;
     body = JSON.stringify(se_DescribeUserProfileRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeUserProfileCommand = se_DescribeUserProfileCommand;
 const se_DescribeWorkforceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeWorkforce",
-    };
+    const headers = sharedHeaders("DescribeWorkforce");
     let body;
     body = JSON.stringify(se_DescribeWorkforceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeWorkforceCommand = se_DescribeWorkforceCommand;
 const se_DescribeWorkteamCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DescribeWorkteam",
-    };
+    const headers = sharedHeaders("DescribeWorkteam");
     let body;
     body = JSON.stringify(se_DescribeWorkteamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeWorkteamCommand = se_DescribeWorkteamCommand;
 const se_DisableSagemakerServicecatalogPortfolioCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DisableSagemakerServicecatalogPortfolio",
-    };
+    const headers = sharedHeaders("DisableSagemakerServicecatalogPortfolio");
     let body;
     body = JSON.stringify(se_DisableSagemakerServicecatalogPortfolioInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DisableSagemakerServicecatalogPortfolioCommand = se_DisableSagemakerServicecatalogPortfolioCommand;
 const se_DisassociateTrialComponentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.DisassociateTrialComponent",
-    };
+    const headers = sharedHeaders("DisassociateTrialComponent");
     let body;
     body = JSON.stringify(se_DisassociateTrialComponentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DisassociateTrialComponentCommand = se_DisassociateTrialComponentCommand;
 const se_EnableSagemakerServicecatalogPortfolioCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.EnableSagemakerServicecatalogPortfolio",
-    };
+    const headers = sharedHeaders("EnableSagemakerServicecatalogPortfolio");
     let body;
     body = JSON.stringify(se_EnableSagemakerServicecatalogPortfolioInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_EnableSagemakerServicecatalogPortfolioCommand = se_EnableSagemakerServicecatalogPortfolioCommand;
 const se_GetDeviceFleetReportCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.GetDeviceFleetReport",
-    };
+    const headers = sharedHeaders("GetDeviceFleetReport");
     let body;
     body = JSON.stringify(se_GetDeviceFleetReportRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDeviceFleetReportCommand = se_GetDeviceFleetReportCommand;
 const se_GetLineageGroupPolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.GetLineageGroupPolicy",
-    };
+    const headers = sharedHeaders("GetLineageGroupPolicy");
     let body;
     body = JSON.stringify(se_GetLineageGroupPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetLineageGroupPolicyCommand = se_GetLineageGroupPolicyCommand;
 const se_GetModelPackageGroupPolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.GetModelPackageGroupPolicy",
-    };
+    const headers = sharedHeaders("GetModelPackageGroupPolicy");
     let body;
     body = JSON.stringify(se_GetModelPackageGroupPolicyInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetModelPackageGroupPolicyCommand = se_GetModelPackageGroupPolicyCommand;
 const se_GetSagemakerServicecatalogPortfolioStatusCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.GetSagemakerServicecatalogPortfolioStatus",
-    };
+    const headers = sharedHeaders("GetSagemakerServicecatalogPortfolioStatus");
     let body;
     body = JSON.stringify(se_GetSagemakerServicecatalogPortfolioStatusInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSagemakerServicecatalogPortfolioStatusCommand = se_GetSagemakerServicecatalogPortfolioStatusCommand;
 const se_GetSearchSuggestionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.GetSearchSuggestions",
-    };
+    const headers = sharedHeaders("GetSearchSuggestions");
     let body;
     body = JSON.stringify(se_GetSearchSuggestionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSearchSuggestionsCommand = se_GetSearchSuggestionsCommand;
 const se_ImportHubContentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ImportHubContent",
-    };
+    const headers = sharedHeaders("ImportHubContent");
     let body;
     body = JSON.stringify(se_ImportHubContentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ImportHubContentCommand = se_ImportHubContentCommand;
 const se_ListActionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListActions",
-    };
+    const headers = sharedHeaders("ListActions");
     let body;
     body = JSON.stringify(se_ListActionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListActionsCommand = se_ListActionsCommand;
 const se_ListAlgorithmsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListAlgorithms",
-    };
+    const headers = sharedHeaders("ListAlgorithms");
     let body;
     body = JSON.stringify(se_ListAlgorithmsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListAlgorithmsCommand = se_ListAlgorithmsCommand;
 const se_ListAliasesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListAliases",
-    };
+    const headers = sharedHeaders("ListAliases");
     let body;
     body = JSON.stringify(se_ListAliasesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListAliasesCommand = se_ListAliasesCommand;
 const se_ListAppImageConfigsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListAppImageConfigs",
-    };
+    const headers = sharedHeaders("ListAppImageConfigs");
     let body;
     body = JSON.stringify(se_ListAppImageConfigsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListAppImageConfigsCommand = se_ListAppImageConfigsCommand;
-const se_ListAppsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListApps",
-    };
+const se_ListAppsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListApps");
     let body;
     body = JSON.stringify(se_ListAppsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListAppsCommand = se_ListAppsCommand;
 const se_ListArtifactsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListArtifacts",
-    };
+    const headers = sharedHeaders("ListArtifacts");
     let body;
     body = JSON.stringify(se_ListArtifactsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListArtifactsCommand = se_ListArtifactsCommand;
 const se_ListAssociationsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListAssociations",
-    };
+    const headers = sharedHeaders("ListAssociations");
     let body;
     body = JSON.stringify(se_ListAssociationsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListAssociationsCommand = se_ListAssociationsCommand;
 const se_ListAutoMLJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListAutoMLJobs",
-    };
+    const headers = sharedHeaders("ListAutoMLJobs");
     let body;
     body = JSON.stringify(se_ListAutoMLJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListAutoMLJobsCommand = se_ListAutoMLJobsCommand;
 const se_ListCandidatesForAutoMLJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListCandidatesForAutoMLJob",
-    };
+    const headers = sharedHeaders("ListCandidatesForAutoMLJob");
     let body;
     body = JSON.stringify(se_ListCandidatesForAutoMLJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCandidatesForAutoMLJobCommand = se_ListCandidatesForAutoMLJobCommand;
 const se_ListCodeRepositoriesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListCodeRepositories",
-    };
+    const headers = sharedHeaders("ListCodeRepositories");
     let body;
     body = JSON.stringify(se_ListCodeRepositoriesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCodeRepositoriesCommand = se_ListCodeRepositoriesCommand;
 const se_ListCompilationJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListCompilationJobs",
-    };
+    const headers = sharedHeaders("ListCompilationJobs");
     let body;
     body = JSON.stringify(se_ListCompilationJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListCompilationJobsCommand = se_ListCompilationJobsCommand;
 const se_ListContextsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListContexts",
-    };
+    const headers = sharedHeaders("ListContexts");
     let body;
     body = JSON.stringify(se_ListContextsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListContextsCommand = se_ListContextsCommand;
 const se_ListDataQualityJobDefinitionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListDataQualityJobDefinitions",
-    };
+    const headers = sharedHeaders("ListDataQualityJobDefinitions");
     let body;
     body = JSON.stringify(se_ListDataQualityJobDefinitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDataQualityJobDefinitionsCommand = se_ListDataQualityJobDefinitionsCommand;
 const se_ListDeviceFleetsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListDeviceFleets",
-    };
+    const headers = sharedHeaders("ListDeviceFleets");
     let body;
     body = JSON.stringify(se_ListDeviceFleetsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDeviceFleetsCommand = se_ListDeviceFleetsCommand;
 const se_ListDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListDevices",
-    };
+    const headers = sharedHeaders("ListDevices");
     let body;
     body = JSON.stringify(se_ListDevicesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDevicesCommand = se_ListDevicesCommand;
 const se_ListDomainsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListDomains",
-    };
+    const headers = sharedHeaders("ListDomains");
     let body;
     body = JSON.stringify(se_ListDomainsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListDomainsCommand = se_ListDomainsCommand;
 const se_ListEdgeDeploymentPlansCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListEdgeDeploymentPlans",
-    };
+    const headers = sharedHeaders("ListEdgeDeploymentPlans");
     let body;
     body = JSON.stringify(se_ListEdgeDeploymentPlansRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListEdgeDeploymentPlansCommand = se_ListEdgeDeploymentPlansCommand;
 const se_ListEdgePackagingJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListEdgePackagingJobs",
-    };
+    const headers = sharedHeaders("ListEdgePackagingJobs");
     let body;
     body = JSON.stringify(se_ListEdgePackagingJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListEdgePackagingJobsCommand = se_ListEdgePackagingJobsCommand;
 const se_ListEndpointConfigsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListEndpointConfigs",
-    };
+    const headers = sharedHeaders("ListEndpointConfigs");
     let body;
     body = JSON.stringify(se_ListEndpointConfigsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListEndpointConfigsCommand = se_ListEndpointConfigsCommand;
 const se_ListEndpointsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListEndpoints",
-    };
+    const headers = sharedHeaders("ListEndpoints");
     let body;
     body = JSON.stringify(se_ListEndpointsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListEndpointsCommand = se_ListEndpointsCommand;
 const se_ListExperimentsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListExperiments",
-    };
+    const headers = sharedHeaders("ListExperiments");
     let body;
     body = JSON.stringify(se_ListExperimentsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListExperimentsCommand = se_ListExperimentsCommand;
 const se_ListFeatureGroupsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListFeatureGroups",
-    };
+    const headers = sharedHeaders("ListFeatureGroups");
     let body;
     body = JSON.stringify(se_ListFeatureGroupsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListFeatureGroupsCommand = se_ListFeatureGroupsCommand;
 const se_ListFlowDefinitionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListFlowDefinitions",
-    };
+    const headers = sharedHeaders("ListFlowDefinitions");
     let body;
     body = JSON.stringify(se_ListFlowDefinitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListFlowDefinitionsCommand = se_ListFlowDefinitionsCommand;
 const se_ListHubContentsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListHubContents",
-    };
+    const headers = sharedHeaders("ListHubContents");
     let body;
     body = JSON.stringify(se_ListHubContentsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListHubContentsCommand = se_ListHubContentsCommand;
 const se_ListHubContentVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListHubContentVersions",
-    };
+    const headers = sharedHeaders("ListHubContentVersions");
     let body;
     body = JSON.stringify(se_ListHubContentVersionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListHubContentVersionsCommand = se_ListHubContentVersionsCommand;
 const se_ListHubsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListHubs",
-    };
+    const headers = sharedHeaders("ListHubs");
     let body;
     body = JSON.stringify(se_ListHubsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListHubsCommand = se_ListHubsCommand;
 const se_ListHumanTaskUisCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListHumanTaskUis",
-    };
+    const headers = sharedHeaders("ListHumanTaskUis");
     let body;
     body = JSON.stringify(se_ListHumanTaskUisRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListHumanTaskUisCommand = se_ListHumanTaskUisCommand;
 const se_ListHyperParameterTuningJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListHyperParameterTuningJobs",
-    };
+    const headers = sharedHeaders("ListHyperParameterTuningJobs");
     let body;
     body = JSON.stringify(se_ListHyperParameterTuningJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListHyperParameterTuningJobsCommand = se_ListHyperParameterTuningJobsCommand;
 const se_ListImagesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListImages",
-    };
+    const headers = sharedHeaders("ListImages");
     let body;
     body = JSON.stringify(se_ListImagesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListImagesCommand = se_ListImagesCommand;
 const se_ListImageVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListImageVersions",
-    };
+    const headers = sharedHeaders("ListImageVersions");
     let body;
     body = JSON.stringify(se_ListImageVersionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListImageVersionsCommand = se_ListImageVersionsCommand;
 const se_ListInferenceExperimentsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListInferenceExperiments",
-    };
+    const headers = sharedHeaders("ListInferenceExperiments");
     let body;
     body = JSON.stringify(se_ListInferenceExperimentsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListInferenceExperimentsCommand = se_ListInferenceExperimentsCommand;
 const se_ListInferenceRecommendationsJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListInferenceRecommendationsJobs",
-    };
+    const headers = sharedHeaders("ListInferenceRecommendationsJobs");
     let body;
     body = JSON.stringify(se_ListInferenceRecommendationsJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListInferenceRecommendationsJobsCommand = se_ListInferenceRecommendationsJobsCommand;
 const se_ListInferenceRecommendationsJobStepsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListInferenceRecommendationsJobSteps",
-    };
+    const headers = sharedHeaders("ListInferenceRecommendationsJobSteps");
     let body;
     body = JSON.stringify(se_ListInferenceRecommendationsJobStepsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListInferenceRecommendationsJobStepsCommand = se_ListInferenceRecommendationsJobStepsCommand;
 const se_ListLabelingJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListLabelingJobs",
-    };
+    const headers = sharedHeaders("ListLabelingJobs");
     let body;
     body = JSON.stringify(se_ListLabelingJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListLabelingJobsCommand = se_ListLabelingJobsCommand;
 const se_ListLabelingJobsForWorkteamCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListLabelingJobsForWorkteam",
-    };
+    const headers = sharedHeaders("ListLabelingJobsForWorkteam");
     let body;
     body = JSON.stringify(se_ListLabelingJobsForWorkteamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListLabelingJobsForWorkteamCommand = se_ListLabelingJobsForWorkteamCommand;
 const se_ListLineageGroupsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListLineageGroups",
-    };
+    const headers = sharedHeaders("ListLineageGroups");
     let body;
     body = JSON.stringify(se_ListLineageGroupsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListLineageGroupsCommand = se_ListLineageGroupsCommand;
 const se_ListModelBiasJobDefinitionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelBiasJobDefinitions",
-    };
+    const headers = sharedHeaders("ListModelBiasJobDefinitions");
     let body;
     body = JSON.stringify(se_ListModelBiasJobDefinitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelBiasJobDefinitionsCommand = se_ListModelBiasJobDefinitionsCommand;
 const se_ListModelCardExportJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelCardExportJobs",
-    };
+    const headers = sharedHeaders("ListModelCardExportJobs");
     let body;
     body = JSON.stringify(se_ListModelCardExportJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelCardExportJobsCommand = se_ListModelCardExportJobsCommand;
 const se_ListModelCardsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelCards",
-    };
+    const headers = sharedHeaders("ListModelCards");
     let body;
     body = JSON.stringify(se_ListModelCardsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelCardsCommand = se_ListModelCardsCommand;
 const se_ListModelCardVersionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelCardVersions",
-    };
+    const headers = sharedHeaders("ListModelCardVersions");
     let body;
     body = JSON.stringify(se_ListModelCardVersionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelCardVersionsCommand = se_ListModelCardVersionsCommand;
 const se_ListModelExplainabilityJobDefinitionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelExplainabilityJobDefinitions",
-    };
+    const headers = sharedHeaders("ListModelExplainabilityJobDefinitions");
     let body;
     body = JSON.stringify(se_ListModelExplainabilityJobDefinitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelExplainabilityJobDefinitionsCommand = se_ListModelExplainabilityJobDefinitionsCommand;
 const se_ListModelMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelMetadata",
-    };
+    const headers = sharedHeaders("ListModelMetadata");
     let body;
     body = JSON.stringify(se_ListModelMetadataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelMetadataCommand = se_ListModelMetadataCommand;
 const se_ListModelPackageGroupsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelPackageGroups",
-    };
+    const headers = sharedHeaders("ListModelPackageGroups");
     let body;
     body = JSON.stringify(se_ListModelPackageGroupsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelPackageGroupsCommand = se_ListModelPackageGroupsCommand;
 const se_ListModelPackagesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelPackages",
-    };
+    const headers = sharedHeaders("ListModelPackages");
     let body;
     body = JSON.stringify(se_ListModelPackagesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelPackagesCommand = se_ListModelPackagesCommand;
 const se_ListModelQualityJobDefinitionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModelQualityJobDefinitions",
-    };
+    const headers = sharedHeaders("ListModelQualityJobDefinitions");
     let body;
     body = JSON.stringify(se_ListModelQualityJobDefinitionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelQualityJobDefinitionsCommand = se_ListModelQualityJobDefinitionsCommand;
 const se_ListModelsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListModels",
-    };
+    const headers = sharedHeaders("ListModels");
     let body;
     body = JSON.stringify(se_ListModelsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListModelsCommand = se_ListModelsCommand;
 const se_ListMonitoringAlertHistoryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListMonitoringAlertHistory",
-    };
+    const headers = sharedHeaders("ListMonitoringAlertHistory");
     let body;
     body = JSON.stringify(se_ListMonitoringAlertHistoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListMonitoringAlertHistoryCommand = se_ListMonitoringAlertHistoryCommand;
 const se_ListMonitoringAlertsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListMonitoringAlerts",
-    };
+    const headers = sharedHeaders("ListMonitoringAlerts");
     let body;
     body = JSON.stringify(se_ListMonitoringAlertsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListMonitoringAlertsCommand = se_ListMonitoringAlertsCommand;
 const se_ListMonitoringExecutionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListMonitoringExecutions",
-    };
+    const headers = sharedHeaders("ListMonitoringExecutions");
     let body;
     body = JSON.stringify(se_ListMonitoringExecutionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListMonitoringExecutionsCommand = se_ListMonitoringExecutionsCommand;
 const se_ListMonitoringSchedulesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListMonitoringSchedules",
-    };
+    const headers = sharedHeaders("ListMonitoringSchedules");
     let body;
     body = JSON.stringify(se_ListMonitoringSchedulesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListMonitoringSchedulesCommand = se_ListMonitoringSchedulesCommand;
 const se_ListNotebookInstanceLifecycleConfigsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListNotebookInstanceLifecycleConfigs",
-    };
+    const headers = sharedHeaders("ListNotebookInstanceLifecycleConfigs");
     let body;
     body = JSON.stringify(se_ListNotebookInstanceLifecycleConfigsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListNotebookInstanceLifecycleConfigsCommand = se_ListNotebookInstanceLifecycleConfigsCommand;
 const se_ListNotebookInstancesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListNotebookInstances",
-    };
+    const headers = sharedHeaders("ListNotebookInstances");
     let body;
     body = JSON.stringify(se_ListNotebookInstancesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListNotebookInstancesCommand = se_ListNotebookInstancesCommand;
 const se_ListPipelineExecutionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListPipelineExecutions",
-    };
+    const headers = sharedHeaders("ListPipelineExecutions");
     let body;
     body = JSON.stringify(se_ListPipelineExecutionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListPipelineExecutionsCommand = se_ListPipelineExecutionsCommand;
 const se_ListPipelineExecutionStepsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListPipelineExecutionSteps",
-    };
+    const headers = sharedHeaders("ListPipelineExecutionSteps");
     let body;
     body = JSON.stringify(se_ListPipelineExecutionStepsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListPipelineExecutionStepsCommand = se_ListPipelineExecutionStepsCommand;
 const se_ListPipelineParametersForExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListPipelineParametersForExecution",
-    };
+    const headers = sharedHeaders("ListPipelineParametersForExecution");
     let body;
     body = JSON.stringify(se_ListPipelineParametersForExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListPipelineParametersForExecutionCommand = se_ListPipelineParametersForExecutionCommand;
 const se_ListPipelinesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListPipelines",
-    };
+    const headers = sharedHeaders("ListPipelines");
     let body;
     body = JSON.stringify(se_ListPipelinesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListPipelinesCommand = se_ListPipelinesCommand;
 const se_ListProcessingJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListProcessingJobs",
-    };
+    const headers = sharedHeaders("ListProcessingJobs");
     let body;
     body = JSON.stringify(se_ListProcessingJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListProcessingJobsCommand = se_ListProcessingJobsCommand;
 const se_ListProjectsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListProjects",
-    };
+    const headers = sharedHeaders("ListProjects");
     let body;
     body = JSON.stringify(se_ListProjectsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListProjectsCommand = se_ListProjectsCommand;
 const se_ListSpacesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListSpaces",
-    };
+    const headers = sharedHeaders("ListSpaces");
     let body;
     body = JSON.stringify(se_ListSpacesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListSpacesCommand = se_ListSpacesCommand;
 const se_ListStageDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListStageDevices",
-    };
+    const headers = sharedHeaders("ListStageDevices");
     let body;
     body = JSON.stringify(se_ListStageDevicesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListStageDevicesCommand = se_ListStageDevicesCommand;
 const se_ListStudioLifecycleConfigsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListStudioLifecycleConfigs",
-    };
+    const headers = sharedHeaders("ListStudioLifecycleConfigs");
     let body;
     body = JSON.stringify(se_ListStudioLifecycleConfigsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListStudioLifecycleConfigsCommand = se_ListStudioLifecycleConfigsCommand;
 const se_ListSubscribedWorkteamsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListSubscribedWorkteams",
-    };
+    const headers = sharedHeaders("ListSubscribedWorkteams");
     let body;
     body = JSON.stringify(se_ListSubscribedWorkteamsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListSubscribedWorkteamsCommand = se_ListSubscribedWorkteamsCommand;
 const se_ListTagsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListTags",
-    };
+    const headers = sharedHeaders("ListTags");
     let body;
     body = JSON.stringify(se_ListTagsInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTagsCommand = se_ListTagsCommand;
 const se_ListTrainingJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListTrainingJobs",
-    };
+    const headers = sharedHeaders("ListTrainingJobs");
     let body;
     body = JSON.stringify(se_ListTrainingJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTrainingJobsCommand = se_ListTrainingJobsCommand;
 const se_ListTrainingJobsForHyperParameterTuningJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListTrainingJobsForHyperParameterTuningJob",
-    };
+    const headers = sharedHeaders("ListTrainingJobsForHyperParameterTuningJob");
     let body;
     body = JSON.stringify(se_ListTrainingJobsForHyperParameterTuningJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTrainingJobsForHyperParameterTuningJobCommand = se_ListTrainingJobsForHyperParameterTuningJobCommand;
 const se_ListTransformJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListTransformJobs",
-    };
+    const headers = sharedHeaders("ListTransformJobs");
     let body;
     body = JSON.stringify(se_ListTransformJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTransformJobsCommand = se_ListTransformJobsCommand;
 const se_ListTrialComponentsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListTrialComponents",
-    };
+    const headers = sharedHeaders("ListTrialComponents");
     let body;
     body = JSON.stringify(se_ListTrialComponentsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTrialComponentsCommand = se_ListTrialComponentsCommand;
 const se_ListTrialsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListTrials",
-    };
+    const headers = sharedHeaders("ListTrials");
     let body;
     body = JSON.stringify(se_ListTrialsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTrialsCommand = se_ListTrialsCommand;
 const se_ListUserProfilesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListUserProfiles",
-    };
+    const headers = sharedHeaders("ListUserProfiles");
     let body;
     body = JSON.stringify(se_ListUserProfilesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListUserProfilesCommand = se_ListUserProfilesCommand;
 const se_ListWorkforcesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListWorkforces",
-    };
+    const headers = sharedHeaders("ListWorkforces");
     let body;
     body = JSON.stringify(se_ListWorkforcesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListWorkforcesCommand = se_ListWorkforcesCommand;
 const se_ListWorkteamsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.ListWorkteams",
-    };
+    const headers = sharedHeaders("ListWorkteams");
     let body;
     body = JSON.stringify(se_ListWorkteamsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListWorkteamsCommand = se_ListWorkteamsCommand;
 const se_PutModelPackageGroupPolicyCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.PutModelPackageGroupPolicy",
-    };
+    const headers = sharedHeaders("PutModelPackageGroupPolicy");
     let body;
     body = JSON.stringify(se_PutModelPackageGroupPolicyInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_PutModelPackageGroupPolicyCommand = se_PutModelPackageGroupPolicyCommand;
 const se_QueryLineageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.QueryLineage",
-    };
+    const headers = sharedHeaders("QueryLineage");
     let body;
     body = JSON.stringify(se_QueryLineageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_QueryLineageCommand = se_QueryLineageCommand;
 const se_RegisterDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.RegisterDevices",
-    };
+    const headers = sharedHeaders("RegisterDevices");
     let body;
     body = JSON.stringify(se_RegisterDevicesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RegisterDevicesCommand = se_RegisterDevicesCommand;
 const se_RenderUiTemplateCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.RenderUiTemplate",
-    };
+    const headers = sharedHeaders("RenderUiTemplate");
     let body;
     body = JSON.stringify(se_RenderUiTemplateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RenderUiTemplateCommand = se_RenderUiTemplateCommand;
 const se_RetryPipelineExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.RetryPipelineExecution",
-    };
+    const headers = sharedHeaders("RetryPipelineExecution");
     let body;
     body = JSON.stringify(se_RetryPipelineExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RetryPipelineExecutionCommand = se_RetryPipelineExecutionCommand;
 const se_SearchCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.Search",
-    };
+    const headers = sharedHeaders("Search");
     let body;
     body = JSON.stringify(se_SearchRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SearchCommand = se_SearchCommand;
 const se_SendPipelineExecutionStepFailureCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.SendPipelineExecutionStepFailure",
-    };
+    const headers = sharedHeaders("SendPipelineExecutionStepFailure");
     let body;
     body = JSON.stringify(se_SendPipelineExecutionStepFailureRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SendPipelineExecutionStepFailureCommand = se_SendPipelineExecutionStepFailureCommand;
 const se_SendPipelineExecutionStepSuccessCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.SendPipelineExecutionStepSuccess",
-    };
+    const headers = sharedHeaders("SendPipelineExecutionStepSuccess");
     let body;
     body = JSON.stringify(se_SendPipelineExecutionStepSuccessRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SendPipelineExecutionStepSuccessCommand = se_SendPipelineExecutionStepSuccessCommand;
 const se_StartEdgeDeploymentStageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StartEdgeDeploymentStage",
-    };
+    const headers = sharedHeaders("StartEdgeDeploymentStage");
     let body;
     body = JSON.stringify(se_StartEdgeDeploymentStageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartEdgeDeploymentStageCommand = se_StartEdgeDeploymentStageCommand;
 const se_StartInferenceExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StartInferenceExperiment",
-    };
+    const headers = sharedHeaders("StartInferenceExperiment");
     let body;
     body = JSON.stringify(se_StartInferenceExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartInferenceExperimentCommand = se_StartInferenceExperimentCommand;
 const se_StartMonitoringScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StartMonitoringSchedule",
-    };
+    const headers = sharedHeaders("StartMonitoringSchedule");
     let body;
     body = JSON.stringify(se_StartMonitoringScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartMonitoringScheduleCommand = se_StartMonitoringScheduleCommand;
 const se_StartNotebookInstanceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StartNotebookInstance",
-    };
+    const headers = sharedHeaders("StartNotebookInstance");
     let body;
     body = JSON.stringify(se_StartNotebookInstanceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartNotebookInstanceCommand = se_StartNotebookInstanceCommand;
 const se_StartPipelineExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StartPipelineExecution",
-    };
+    const headers = sharedHeaders("StartPipelineExecution");
     let body;
     body = JSON.stringify(se_StartPipelineExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartPipelineExecutionCommand = se_StartPipelineExecutionCommand;
 const se_StopAutoMLJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopAutoMLJob",
-    };
+    const headers = sharedHeaders("StopAutoMLJob");
     let body;
     body = JSON.stringify(se_StopAutoMLJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopAutoMLJobCommand = se_StopAutoMLJobCommand;
 const se_StopCompilationJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopCompilationJob",
-    };
+    const headers = sharedHeaders("StopCompilationJob");
     let body;
     body = JSON.stringify(se_StopCompilationJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopCompilationJobCommand = se_StopCompilationJobCommand;
 const se_StopEdgeDeploymentStageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopEdgeDeploymentStage",
-    };
+    const headers = sharedHeaders("StopEdgeDeploymentStage");
     let body;
     body = JSON.stringify(se_StopEdgeDeploymentStageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopEdgeDeploymentStageCommand = se_StopEdgeDeploymentStageCommand;
 const se_StopEdgePackagingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopEdgePackagingJob",
-    };
+    const headers = sharedHeaders("StopEdgePackagingJob");
     let body;
     body = JSON.stringify(se_StopEdgePackagingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopEdgePackagingJobCommand = se_StopEdgePackagingJobCommand;
 const se_StopHyperParameterTuningJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopHyperParameterTuningJob",
-    };
+    const headers = sharedHeaders("StopHyperParameterTuningJob");
     let body;
     body = JSON.stringify(se_StopHyperParameterTuningJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopHyperParameterTuningJobCommand = se_StopHyperParameterTuningJobCommand;
 const se_StopInferenceExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopInferenceExperiment",
-    };
+    const headers = sharedHeaders("StopInferenceExperiment");
     let body;
     body = JSON.stringify(se_StopInferenceExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopInferenceExperimentCommand = se_StopInferenceExperimentCommand;
 const se_StopInferenceRecommendationsJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopInferenceRecommendationsJob",
-    };
+    const headers = sharedHeaders("StopInferenceRecommendationsJob");
     let body;
     body = JSON.stringify(se_StopInferenceRecommendationsJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopInferenceRecommendationsJobCommand = se_StopInferenceRecommendationsJobCommand;
 const se_StopLabelingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopLabelingJob",
-    };
+    const headers = sharedHeaders("StopLabelingJob");
     let body;
     body = JSON.stringify(se_StopLabelingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopLabelingJobCommand = se_StopLabelingJobCommand;
 const se_StopMonitoringScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopMonitoringSchedule",
-    };
+    const headers = sharedHeaders("StopMonitoringSchedule");
     let body;
     body = JSON.stringify(se_StopMonitoringScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopMonitoringScheduleCommand = se_StopMonitoringScheduleCommand;
 const se_StopNotebookInstanceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopNotebookInstance",
-    };
+    const headers = sharedHeaders("StopNotebookInstance");
     let body;
     body = JSON.stringify(se_StopNotebookInstanceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopNotebookInstanceCommand = se_StopNotebookInstanceCommand;
 const se_StopPipelineExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopPipelineExecution",
-    };
+    const headers = sharedHeaders("StopPipelineExecution");
     let body;
     body = JSON.stringify(se_StopPipelineExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopPipelineExecutionCommand = se_StopPipelineExecutionCommand;
 const se_StopProcessingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopProcessingJob",
-    };
+    const headers = sharedHeaders("StopProcessingJob");
     let body;
     body = JSON.stringify(se_StopProcessingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopProcessingJobCommand = se_StopProcessingJobCommand;
 const se_StopTrainingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopTrainingJob",
-    };
+    const headers = sharedHeaders("StopTrainingJob");
     let body;
     body = JSON.stringify(se_StopTrainingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopTrainingJobCommand = se_StopTrainingJobCommand;
 const se_StopTransformJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.StopTransformJob",
-    };
+    const headers = sharedHeaders("StopTransformJob");
     let body;
     body = JSON.stringify(se_StopTransformJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopTransformJobCommand = se_StopTransformJobCommand;
 const se_UpdateActionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateAction",
-    };
+    const headers = sharedHeaders("UpdateAction");
     let body;
     body = JSON.stringify(se_UpdateActionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateActionCommand = se_UpdateActionCommand;
 const se_UpdateAppImageConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateAppImageConfig",
-    };
+    const headers = sharedHeaders("UpdateAppImageConfig");
     let body;
     body = JSON.stringify(se_UpdateAppImageConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateAppImageConfigCommand = se_UpdateAppImageConfigCommand;
 const se_UpdateArtifactCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateArtifact",
-    };
+    const headers = sharedHeaders("UpdateArtifact");
     let body;
     body = JSON.stringify(se_UpdateArtifactRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateArtifactCommand = se_UpdateArtifactCommand;
 const se_UpdateCodeRepositoryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateCodeRepository",
-    };
+    const headers = sharedHeaders("UpdateCodeRepository");
     let body;
     body = JSON.stringify(se_UpdateCodeRepositoryInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateCodeRepositoryCommand = se_UpdateCodeRepositoryCommand;
 const se_UpdateContextCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateContext",
-    };
+    const headers = sharedHeaders("UpdateContext");
     let body;
     body = JSON.stringify(se_UpdateContextRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateContextCommand = se_UpdateContextCommand;
 const se_UpdateDeviceFleetCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateDeviceFleet",
-    };
+    const headers = sharedHeaders("UpdateDeviceFleet");
     let body;
     body = JSON.stringify(se_UpdateDeviceFleetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDeviceFleetCommand = se_UpdateDeviceFleetCommand;
 const se_UpdateDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateDevices",
-    };
+    const headers = sharedHeaders("UpdateDevices");
     let body;
     body = JSON.stringify(se_UpdateDevicesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDevicesCommand = se_UpdateDevicesCommand;
 const se_UpdateDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateDomain",
-    };
+    const headers = sharedHeaders("UpdateDomain");
     let body;
     body = JSON.stringify(se_UpdateDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDomainCommand = se_UpdateDomainCommand;
 const se_UpdateEndpointCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateEndpoint",
-    };
+    const headers = sharedHeaders("UpdateEndpoint");
     let body;
     body = JSON.stringify(se_UpdateEndpointInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateEndpointCommand = se_UpdateEndpointCommand;
 const se_UpdateEndpointWeightsAndCapacitiesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateEndpointWeightsAndCapacities",
-    };
+    const headers = sharedHeaders("UpdateEndpointWeightsAndCapacities");
     let body;
     body = JSON.stringify(se_UpdateEndpointWeightsAndCapacitiesInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateEndpointWeightsAndCapacitiesCommand = se_UpdateEndpointWeightsAndCapacitiesCommand;
 const se_UpdateExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateExperiment",
-    };
+    const headers = sharedHeaders("UpdateExperiment");
     let body;
     body = JSON.stringify(se_UpdateExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateExperimentCommand = se_UpdateExperimentCommand;
 const se_UpdateFeatureGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateFeatureGroup",
-    };
+    const headers = sharedHeaders("UpdateFeatureGroup");
     let body;
     body = JSON.stringify(se_UpdateFeatureGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateFeatureGroupCommand = se_UpdateFeatureGroupCommand;
 const se_UpdateFeatureMetadataCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateFeatureMetadata",
-    };
+    const headers = sharedHeaders("UpdateFeatureMetadata");
     let body;
     body = JSON.stringify(se_UpdateFeatureMetadataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateFeatureMetadataCommand = se_UpdateFeatureMetadataCommand;
 const se_UpdateHubCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateHub",
-    };
+    const headers = sharedHeaders("UpdateHub");
     let body;
     body = JSON.stringify(se_UpdateHubRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateHubCommand = se_UpdateHubCommand;
 const se_UpdateImageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateImage",
-    };
+    const headers = sharedHeaders("UpdateImage");
     let body;
     body = JSON.stringify(se_UpdateImageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateImageCommand = se_UpdateImageCommand;
 const se_UpdateImageVersionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateImageVersion",
-    };
+    const headers = sharedHeaders("UpdateImageVersion");
     let body;
     body = JSON.stringify(se_UpdateImageVersionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateImageVersionCommand = se_UpdateImageVersionCommand;
 const se_UpdateInferenceExperimentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateInferenceExperiment",
-    };
+    const headers = sharedHeaders("UpdateInferenceExperiment");
     let body;
     body = JSON.stringify(se_UpdateInferenceExperimentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateInferenceExperimentCommand = se_UpdateInferenceExperimentCommand;
 const se_UpdateModelCardCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateModelCard",
-    };
+    const headers = sharedHeaders("UpdateModelCard");
     let body;
     body = JSON.stringify(se_UpdateModelCardRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateModelCardCommand = se_UpdateModelCardCommand;
 const se_UpdateModelPackageCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateModelPackage",
-    };
+    const headers = sharedHeaders("UpdateModelPackage");
     let body;
     body = JSON.stringify(se_UpdateModelPackageInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateModelPackageCommand = se_UpdateModelPackageCommand;
 const se_UpdateMonitoringAlertCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateMonitoringAlert",
-    };
+    const headers = sharedHeaders("UpdateMonitoringAlert");
     let body;
     body = JSON.stringify(se_UpdateMonitoringAlertRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateMonitoringAlertCommand = se_UpdateMonitoringAlertCommand;
 const se_UpdateMonitoringScheduleCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateMonitoringSchedule",
-    };
+    const headers = sharedHeaders("UpdateMonitoringSchedule");
     let body;
     body = JSON.stringify(se_UpdateMonitoringScheduleRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateMonitoringScheduleCommand = se_UpdateMonitoringScheduleCommand;
 const se_UpdateNotebookInstanceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateNotebookInstance",
-    };
+    const headers = sharedHeaders("UpdateNotebookInstance");
     let body;
     body = JSON.stringify(se_UpdateNotebookInstanceInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateNotebookInstanceCommand = se_UpdateNotebookInstanceCommand;
 const se_UpdateNotebookInstanceLifecycleConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateNotebookInstanceLifecycleConfig",
-    };
+    const headers = sharedHeaders("UpdateNotebookInstanceLifecycleConfig");
     let body;
     body = JSON.stringify(se_UpdateNotebookInstanceLifecycleConfigInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateNotebookInstanceLifecycleConfigCommand = se_UpdateNotebookInstanceLifecycleConfigCommand;
 const se_UpdatePipelineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdatePipeline",
-    };
+    const headers = sharedHeaders("UpdatePipeline");
     let body;
     body = JSON.stringify(se_UpdatePipelineRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdatePipelineCommand = se_UpdatePipelineCommand;
 const se_UpdatePipelineExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdatePipelineExecution",
-    };
+    const headers = sharedHeaders("UpdatePipelineExecution");
     let body;
     body = JSON.stringify(se_UpdatePipelineExecutionRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdatePipelineExecutionCommand = se_UpdatePipelineExecutionCommand;
 const se_UpdateProjectCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateProject",
-    };
+    const headers = sharedHeaders("UpdateProject");
     let body;
     body = JSON.stringify(se_UpdateProjectInput(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateProjectCommand = se_UpdateProjectCommand;
 const se_UpdateSpaceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateSpace",
-    };
+    const headers = sharedHeaders("UpdateSpace");
     let body;
     body = JSON.stringify(se_UpdateSpaceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateSpaceCommand = se_UpdateSpaceCommand;
 const se_UpdateTrainingJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateTrainingJob",
-    };
+    const headers = sharedHeaders("UpdateTrainingJob");
     let body;
     body = JSON.stringify(se_UpdateTrainingJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateTrainingJobCommand = se_UpdateTrainingJobCommand;
 const se_UpdateTrialCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateTrial",
-    };
+    const headers = sharedHeaders("UpdateTrial");
     let body;
     body = JSON.stringify(se_UpdateTrialRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateTrialCommand = se_UpdateTrialCommand;
 const se_UpdateTrialComponentCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateTrialComponent",
-    };
+    const headers = sharedHeaders("UpdateTrialComponent");
     let body;
     body = JSON.stringify(se_UpdateTrialComponentRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateTrialComponentCommand = se_UpdateTrialComponentCommand;
 const se_UpdateUserProfileCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateUserProfile",
-    };
+    const headers = sharedHeaders("UpdateUserProfile");
     let body;
     body = JSON.stringify(se_UpdateUserProfileRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateUserProfileCommand = se_UpdateUserProfileCommand;
 const se_UpdateWorkforceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateWorkforce",
-    };
+    const headers = sharedHeaders("UpdateWorkforce");
     let body;
     body = JSON.stringify(se_UpdateWorkforceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateWorkforceCommand = se_UpdateWorkforceCommand;
 const se_UpdateWorkteamCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "SageMaker.UpdateWorkteam",
-    };
+    const headers = sharedHeaders("UpdateWorkteam");
     let body;
     body = JSON.stringify(se_UpdateWorkteamRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
@@ -28520,6 +27614,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": `SageMaker.${operation}`,
+    };
+}
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);