@aws-sdk/client-cognito-identity-provider 3.309.0 → 3.312.0

package/dist-cjs/protocols/Aws_json1_1.js

@@ -11,1010 +11,707 @@ const CognitoIdentityProviderServiceException_1 = require("../models/CognitoIden
 const models_0_1 = require("../models/models_0");
 const models_1_1 = require("../models/models_1");
 const se_AddCustomAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AddCustomAttributes",
-    };
+    const headers = sharedHeaders("AddCustomAttributes");
     let body;
     body = JSON.stringify(se_AddCustomAttributesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AddCustomAttributesCommand = se_AddCustomAttributesCommand;
 const se_AdminAddUserToGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminAddUserToGroup",
-    };
+    const headers = sharedHeaders("AdminAddUserToGroup");
     let body;
     body = JSON.stringify(se_AdminAddUserToGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminAddUserToGroupCommand = se_AdminAddUserToGroupCommand;
 const se_AdminConfirmSignUpCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminConfirmSignUp",
-    };
+    const headers = sharedHeaders("AdminConfirmSignUp");
     let body;
     body = JSON.stringify(se_AdminConfirmSignUpRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminConfirmSignUpCommand = se_AdminConfirmSignUpCommand;
 const se_AdminCreateUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminCreateUser",
-    };
+    const headers = sharedHeaders("AdminCreateUser");
     let body;
     body = JSON.stringify(se_AdminCreateUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminCreateUserCommand = se_AdminCreateUserCommand;
 const se_AdminDeleteUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminDeleteUser",
-    };
+    const headers = sharedHeaders("AdminDeleteUser");
     let body;
     body = JSON.stringify(se_AdminDeleteUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminDeleteUserCommand = se_AdminDeleteUserCommand;
 const se_AdminDeleteUserAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminDeleteUserAttributes",
-    };
+    const headers = sharedHeaders("AdminDeleteUserAttributes");
     let body;
     body = JSON.stringify(se_AdminDeleteUserAttributesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminDeleteUserAttributesCommand = se_AdminDeleteUserAttributesCommand;
 const se_AdminDisableProviderForUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminDisableProviderForUser",
-    };
+    const headers = sharedHeaders("AdminDisableProviderForUser");
     let body;
     body = JSON.stringify(se_AdminDisableProviderForUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminDisableProviderForUserCommand = se_AdminDisableProviderForUserCommand;
 const se_AdminDisableUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminDisableUser",
-    };
+    const headers = sharedHeaders("AdminDisableUser");
     let body;
     body = JSON.stringify(se_AdminDisableUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminDisableUserCommand = se_AdminDisableUserCommand;
 const se_AdminEnableUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminEnableUser",
-    };
+    const headers = sharedHeaders("AdminEnableUser");
     let body;
     body = JSON.stringify(se_AdminEnableUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminEnableUserCommand = se_AdminEnableUserCommand;
 const se_AdminForgetDeviceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminForgetDevice",
-    };
+    const headers = sharedHeaders("AdminForgetDevice");
     let body;
     body = JSON.stringify(se_AdminForgetDeviceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminForgetDeviceCommand = se_AdminForgetDeviceCommand;
 const se_AdminGetDeviceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminGetDevice",
-    };
+    const headers = sharedHeaders("AdminGetDevice");
     let body;
     body = JSON.stringify(se_AdminGetDeviceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminGetDeviceCommand = se_AdminGetDeviceCommand;
 const se_AdminGetUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminGetUser",
-    };
+    const headers = sharedHeaders("AdminGetUser");
     let body;
     body = JSON.stringify(se_AdminGetUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminGetUserCommand = se_AdminGetUserCommand;
 const se_AdminInitiateAuthCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminInitiateAuth",
-    };
+    const headers = sharedHeaders("AdminInitiateAuth");
     let body;
     body = JSON.stringify(se_AdminInitiateAuthRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminInitiateAuthCommand = se_AdminInitiateAuthCommand;
 const se_AdminLinkProviderForUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminLinkProviderForUser",
-    };
+    const headers = sharedHeaders("AdminLinkProviderForUser");
     let body;
     body = JSON.stringify(se_AdminLinkProviderForUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminLinkProviderForUserCommand = se_AdminLinkProviderForUserCommand;
 const se_AdminListDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminListDevices",
-    };
+    const headers = sharedHeaders("AdminListDevices");
     let body;
     body = JSON.stringify(se_AdminListDevicesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminListDevicesCommand = se_AdminListDevicesCommand;
 const se_AdminListGroupsForUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminListGroupsForUser",
-    };
+    const headers = sharedHeaders("AdminListGroupsForUser");
     let body;
     body = JSON.stringify(se_AdminListGroupsForUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminListGroupsForUserCommand = se_AdminListGroupsForUserCommand;
 const se_AdminListUserAuthEventsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminListUserAuthEvents",
-    };
+    const headers = sharedHeaders("AdminListUserAuthEvents");
     let body;
     body = JSON.stringify(se_AdminListUserAuthEventsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminListUserAuthEventsCommand = se_AdminListUserAuthEventsCommand;
 const se_AdminRemoveUserFromGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup",
-    };
+    const headers = sharedHeaders("AdminRemoveUserFromGroup");
     let body;
     body = JSON.stringify(se_AdminRemoveUserFromGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminRemoveUserFromGroupCommand = se_AdminRemoveUserFromGroupCommand;
 const se_AdminResetUserPasswordCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminResetUserPassword",
-    };
+    const headers = sharedHeaders("AdminResetUserPassword");
     let body;
     body = JSON.stringify(se_AdminResetUserPasswordRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminResetUserPasswordCommand = se_AdminResetUserPasswordCommand;
 const se_AdminRespondToAuthChallengeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge",
-    };
+    const headers = sharedHeaders("AdminRespondToAuthChallenge");
     let body;
     body = JSON.stringify(se_AdminRespondToAuthChallengeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminRespondToAuthChallengeCommand = se_AdminRespondToAuthChallengeCommand;
 const se_AdminSetUserMFAPreferenceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminSetUserMFAPreference",
-    };
+    const headers = sharedHeaders("AdminSetUserMFAPreference");
     let body;
     body = JSON.stringify(se_AdminSetUserMFAPreferenceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminSetUserMFAPreferenceCommand = se_AdminSetUserMFAPreferenceCommand;
 const se_AdminSetUserPasswordCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminSetUserPassword",
-    };
+    const headers = sharedHeaders("AdminSetUserPassword");
     let body;
     body = JSON.stringify(se_AdminSetUserPasswordRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminSetUserPasswordCommand = se_AdminSetUserPasswordCommand;
 const se_AdminSetUserSettingsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminSetUserSettings",
-    };
+    const headers = sharedHeaders("AdminSetUserSettings");
     let body;
     body = JSON.stringify(se_AdminSetUserSettingsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminSetUserSettingsCommand = se_AdminSetUserSettingsCommand;
 const se_AdminUpdateAuthEventFeedbackCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback",
-    };
+    const headers = sharedHeaders("AdminUpdateAuthEventFeedback");
     let body;
     body = JSON.stringify(se_AdminUpdateAuthEventFeedbackRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminUpdateAuthEventFeedbackCommand = se_AdminUpdateAuthEventFeedbackCommand;
 const se_AdminUpdateDeviceStatusCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus",
-    };
+    const headers = sharedHeaders("AdminUpdateDeviceStatus");
     let body;
     body = JSON.stringify(se_AdminUpdateDeviceStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminUpdateDeviceStatusCommand = se_AdminUpdateDeviceStatusCommand;
 const se_AdminUpdateUserAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminUpdateUserAttributes",
-    };
+    const headers = sharedHeaders("AdminUpdateUserAttributes");
     let body;
     body = JSON.stringify(se_AdminUpdateUserAttributesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminUpdateUserAttributesCommand = se_AdminUpdateUserAttributesCommand;
 const se_AdminUserGlobalSignOutCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AdminUserGlobalSignOut",
-    };
+    const headers = sharedHeaders("AdminUserGlobalSignOut");
     let body;
     body = JSON.stringify(se_AdminUserGlobalSignOutRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AdminUserGlobalSignOutCommand = se_AdminUserGlobalSignOutCommand;
 const se_AssociateSoftwareTokenCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.AssociateSoftwareToken",
-    };
+    const headers = sharedHeaders("AssociateSoftwareToken");
     let body;
     body = JSON.stringify(se_AssociateSoftwareTokenRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_AssociateSoftwareTokenCommand = se_AssociateSoftwareTokenCommand;
 const se_ChangePasswordCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ChangePassword",
-    };
+    const headers = sharedHeaders("ChangePassword");
     let body;
     body = JSON.stringify(se_ChangePasswordRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ChangePasswordCommand = se_ChangePasswordCommand;
 const se_ConfirmDeviceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ConfirmDevice",
-    };
+    const headers = sharedHeaders("ConfirmDevice");
     let body;
     body = JSON.stringify(se_ConfirmDeviceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ConfirmDeviceCommand = se_ConfirmDeviceCommand;
 const se_ConfirmForgotPasswordCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ConfirmForgotPassword",
-    };
+    const headers = sharedHeaders("ConfirmForgotPassword");
     let body;
     body = JSON.stringify(se_ConfirmForgotPasswordRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ConfirmForgotPasswordCommand = se_ConfirmForgotPasswordCommand;
 const se_ConfirmSignUpCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ConfirmSignUp",
-    };
+    const headers = sharedHeaders("ConfirmSignUp");
     let body;
     body = JSON.stringify(se_ConfirmSignUpRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ConfirmSignUpCommand = se_ConfirmSignUpCommand;
 const se_CreateGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateGroup",
-    };
+    const headers = sharedHeaders("CreateGroup");
     let body;
     body = JSON.stringify(se_CreateGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateGroupCommand = se_CreateGroupCommand;
 const se_CreateIdentityProviderCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateIdentityProvider",
-    };
+    const headers = sharedHeaders("CreateIdentityProvider");
     let body;
     body = JSON.stringify(se_CreateIdentityProviderRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateIdentityProviderCommand = se_CreateIdentityProviderCommand;
 const se_CreateResourceServerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateResourceServer",
-    };
+    const headers = sharedHeaders("CreateResourceServer");
     let body;
     body = JSON.stringify(se_CreateResourceServerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateResourceServerCommand = se_CreateResourceServerCommand;
 const se_CreateUserImportJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateUserImportJob",
-    };
+    const headers = sharedHeaders("CreateUserImportJob");
     let body;
     body = JSON.stringify(se_CreateUserImportJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateUserImportJobCommand = se_CreateUserImportJobCommand;
 const se_CreateUserPoolCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateUserPool",
-    };
+    const headers = sharedHeaders("CreateUserPool");
     let body;
     body = JSON.stringify(se_CreateUserPoolRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateUserPoolCommand = se_CreateUserPoolCommand;
 const se_CreateUserPoolClientCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateUserPoolClient",
-    };
+    const headers = sharedHeaders("CreateUserPoolClient");
     let body;
     body = JSON.stringify(se_CreateUserPoolClientRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateUserPoolClientCommand = se_CreateUserPoolClientCommand;
 const se_CreateUserPoolDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.CreateUserPoolDomain",
-    };
+    const headers = sharedHeaders("CreateUserPoolDomain");
     let body;
     body = JSON.stringify(se_CreateUserPoolDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_CreateUserPoolDomainCommand = se_CreateUserPoolDomainCommand;
 const se_DeleteGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteGroup",
-    };
+    const headers = sharedHeaders("DeleteGroup");
     let body;
     body = JSON.stringify(se_DeleteGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteGroupCommand = se_DeleteGroupCommand;
 const se_DeleteIdentityProviderCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteIdentityProvider",
-    };
+    const headers = sharedHeaders("DeleteIdentityProvider");
     let body;
     body = JSON.stringify(se_DeleteIdentityProviderRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteIdentityProviderCommand = se_DeleteIdentityProviderCommand;
 const se_DeleteResourceServerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteResourceServer",
-    };
+    const headers = sharedHeaders("DeleteResourceServer");
     let body;
     body = JSON.stringify(se_DeleteResourceServerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteResourceServerCommand = se_DeleteResourceServerCommand;
 const se_DeleteUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteUser",
-    };
+    const headers = sharedHeaders("DeleteUser");
     let body;
     body = JSON.stringify(se_DeleteUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserCommand = se_DeleteUserCommand;
 const se_DeleteUserAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteUserAttributes",
-    };
+    const headers = sharedHeaders("DeleteUserAttributes");
     let body;
     body = JSON.stringify(se_DeleteUserAttributesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserAttributesCommand = se_DeleteUserAttributesCommand;
 const se_DeleteUserPoolCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteUserPool",
-    };
+    const headers = sharedHeaders("DeleteUserPool");
     let body;
     body = JSON.stringify(se_DeleteUserPoolRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserPoolCommand = se_DeleteUserPoolCommand;
 const se_DeleteUserPoolClientCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteUserPoolClient",
-    };
+    const headers = sharedHeaders("DeleteUserPoolClient");
     let body;
     body = JSON.stringify(se_DeleteUserPoolClientRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserPoolClientCommand = se_DeleteUserPoolClientCommand;
 const se_DeleteUserPoolDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DeleteUserPoolDomain",
-    };
+    const headers = sharedHeaders("DeleteUserPoolDomain");
     let body;
     body = JSON.stringify(se_DeleteUserPoolDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DeleteUserPoolDomainCommand = se_DeleteUserPoolDomainCommand;
 const se_DescribeIdentityProviderCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeIdentityProvider",
-    };
+    const headers = sharedHeaders("DescribeIdentityProvider");
     let body;
     body = JSON.stringify(se_DescribeIdentityProviderRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeIdentityProviderCommand = se_DescribeIdentityProviderCommand;
 const se_DescribeResourceServerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeResourceServer",
-    };
+    const headers = sharedHeaders("DescribeResourceServer");
     let body;
     body = JSON.stringify(se_DescribeResourceServerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeResourceServerCommand = se_DescribeResourceServerCommand;
 const se_DescribeRiskConfigurationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeRiskConfiguration",
-    };
+    const headers = sharedHeaders("DescribeRiskConfiguration");
     let body;
     body = JSON.stringify(se_DescribeRiskConfigurationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeRiskConfigurationCommand = se_DescribeRiskConfigurationCommand;
 const se_DescribeUserImportJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeUserImportJob",
-    };
+    const headers = sharedHeaders("DescribeUserImportJob");
     let body;
     body = JSON.stringify(se_DescribeUserImportJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeUserImportJobCommand = se_DescribeUserImportJobCommand;
 const se_DescribeUserPoolCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeUserPool",
-    };
+    const headers = sharedHeaders("DescribeUserPool");
     let body;
     body = JSON.stringify(se_DescribeUserPoolRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeUserPoolCommand = se_DescribeUserPoolCommand;
 const se_DescribeUserPoolClientCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeUserPoolClient",
-    };
+    const headers = sharedHeaders("DescribeUserPoolClient");
     let body;
     body = JSON.stringify(se_DescribeUserPoolClientRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeUserPoolClientCommand = se_DescribeUserPoolClientCommand;
 const se_DescribeUserPoolDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.DescribeUserPoolDomain",
-    };
+    const headers = sharedHeaders("DescribeUserPoolDomain");
     let body;
     body = JSON.stringify(se_DescribeUserPoolDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_DescribeUserPoolDomainCommand = se_DescribeUserPoolDomainCommand;
 const se_ForgetDeviceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ForgetDevice",
-    };
+    const headers = sharedHeaders("ForgetDevice");
     let body;
     body = JSON.stringify(se_ForgetDeviceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ForgetDeviceCommand = se_ForgetDeviceCommand;
 const se_ForgotPasswordCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ForgotPassword",
-    };
+    const headers = sharedHeaders("ForgotPassword");
     let body;
     body = JSON.stringify(se_ForgotPasswordRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ForgotPasswordCommand = se_ForgotPasswordCommand;
 const se_GetCSVHeaderCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetCSVHeader",
-    };
+    const headers = sharedHeaders("GetCSVHeader");
     let body;
     body = JSON.stringify(se_GetCSVHeaderRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetCSVHeaderCommand = se_GetCSVHeaderCommand;
 const se_GetDeviceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetDevice",
-    };
+    const headers = sharedHeaders("GetDevice");
     let body;
     body = JSON.stringify(se_GetDeviceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetDeviceCommand = se_GetDeviceCommand;
 const se_GetGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetGroup",
-    };
+    const headers = sharedHeaders("GetGroup");
     let body;
     body = JSON.stringify(se_GetGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetGroupCommand = se_GetGroupCommand;
 const se_GetIdentityProviderByIdentifierCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier",
-    };
+    const headers = sharedHeaders("GetIdentityProviderByIdentifier");
     let body;
     body = JSON.stringify(se_GetIdentityProviderByIdentifierRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetIdentityProviderByIdentifierCommand = se_GetIdentityProviderByIdentifierCommand;
 const se_GetSigningCertificateCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetSigningCertificate",
-    };
+    const headers = sharedHeaders("GetSigningCertificate");
     let body;
     body = JSON.stringify(se_GetSigningCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetSigningCertificateCommand = se_GetSigningCertificateCommand;
 const se_GetUICustomizationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetUICustomization",
-    };
+    const headers = sharedHeaders("GetUICustomization");
     let body;
     body = JSON.stringify(se_GetUICustomizationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUICustomizationCommand = se_GetUICustomizationCommand;
 const se_GetUserCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetUser",
-    };
+    const headers = sharedHeaders("GetUser");
     let body;
     body = JSON.stringify(se_GetUserRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUserCommand = se_GetUserCommand;
 const se_GetUserAttributeVerificationCodeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode",
-    };
+    const headers = sharedHeaders("GetUserAttributeVerificationCode");
     let body;
     body = JSON.stringify(se_GetUserAttributeVerificationCodeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUserAttributeVerificationCodeCommand = se_GetUserAttributeVerificationCodeCommand;
 const se_GetUserPoolMfaConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GetUserPoolMfaConfig",
-    };
+    const headers = sharedHeaders("GetUserPoolMfaConfig");
     let body;
     body = JSON.stringify(se_GetUserPoolMfaConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GetUserPoolMfaConfigCommand = se_GetUserPoolMfaConfigCommand;
 const se_GlobalSignOutCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.GlobalSignOut",
-    };
+    const headers = sharedHeaders("GlobalSignOut");
     let body;
     body = JSON.stringify(se_GlobalSignOutRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_GlobalSignOutCommand = se_GlobalSignOutCommand;
 const se_InitiateAuthCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.InitiateAuth",
-    };
+    const headers = sharedHeaders("InitiateAuth");
     let body;
     body = JSON.stringify(se_InitiateAuthRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_InitiateAuthCommand = se_InitiateAuthCommand;
 const se_ListDevicesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.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_ListGroupsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListGroups",
-    };
+    const headers = sharedHeaders("ListGroups");
     let body;
     body = JSON.stringify(se_ListGroupsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListGroupsCommand = se_ListGroupsCommand;
 const se_ListIdentityProvidersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListIdentityProviders",
-    };
+    const headers = sharedHeaders("ListIdentityProviders");
     let body;
     body = JSON.stringify(se_ListIdentityProvidersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListIdentityProvidersCommand = se_ListIdentityProvidersCommand;
 const se_ListResourceServersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListResourceServers",
-    };
+    const headers = sharedHeaders("ListResourceServers");
     let body;
     body = JSON.stringify(se_ListResourceServersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListResourceServersCommand = se_ListResourceServersCommand;
 const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListTagsForResource",
-    };
+    const headers = sharedHeaders("ListTagsForResource");
     let body;
     body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand;
 const se_ListUserImportJobsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListUserImportJobs",
-    };
+    const headers = sharedHeaders("ListUserImportJobs");
     let body;
     body = JSON.stringify(se_ListUserImportJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListUserImportJobsCommand = se_ListUserImportJobsCommand;
 const se_ListUserPoolClientsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListUserPoolClients",
-    };
+    const headers = sharedHeaders("ListUserPoolClients");
     let body;
     body = JSON.stringify(se_ListUserPoolClientsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListUserPoolClientsCommand = se_ListUserPoolClientsCommand;
 const se_ListUserPoolsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListUserPools",
-    };
+    const headers = sharedHeaders("ListUserPools");
     let body;
     body = JSON.stringify(se_ListUserPoolsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListUserPoolsCommand = se_ListUserPoolsCommand;
 const se_ListUsersCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListUsers",
-    };
+    const headers = sharedHeaders("ListUsers");
     let body;
     body = JSON.stringify(se_ListUsersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListUsersCommand = se_ListUsersCommand;
 const se_ListUsersInGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ListUsersInGroup",
-    };
+    const headers = sharedHeaders("ListUsersInGroup");
     let body;
     body = JSON.stringify(se_ListUsersInGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ListUsersInGroupCommand = se_ListUsersInGroupCommand;
 const se_ResendConfirmationCodeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.ResendConfirmationCode",
-    };
+    const headers = sharedHeaders("ResendConfirmationCode");
     let body;
     body = JSON.stringify(se_ResendConfirmationCodeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_ResendConfirmationCodeCommand = se_ResendConfirmationCodeCommand;
 const se_RespondToAuthChallengeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.RespondToAuthChallenge",
-    };
+    const headers = sharedHeaders("RespondToAuthChallenge");
     let body;
     body = JSON.stringify(se_RespondToAuthChallengeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RespondToAuthChallengeCommand = se_RespondToAuthChallengeCommand;
 const se_RevokeTokenCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.RevokeToken",
-    };
+    const headers = sharedHeaders("RevokeToken");
     let body;
     body = JSON.stringify(se_RevokeTokenRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_RevokeTokenCommand = se_RevokeTokenCommand;
 const se_SetRiskConfigurationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.SetRiskConfiguration",
-    };
+    const headers = sharedHeaders("SetRiskConfiguration");
     let body;
     body = JSON.stringify(se_SetRiskConfigurationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SetRiskConfigurationCommand = se_SetRiskConfigurationCommand;
 const se_SetUICustomizationCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.SetUICustomization",
-    };
+    const headers = sharedHeaders("SetUICustomization");
     let body;
     body = JSON.stringify(se_SetUICustomizationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SetUICustomizationCommand = se_SetUICustomizationCommand;
 const se_SetUserMFAPreferenceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.SetUserMFAPreference",
-    };
+    const headers = sharedHeaders("SetUserMFAPreference");
     let body;
     body = JSON.stringify(se_SetUserMFAPreferenceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SetUserMFAPreferenceCommand = se_SetUserMFAPreferenceCommand;
 const se_SetUserPoolMfaConfigCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.SetUserPoolMfaConfig",
-    };
+    const headers = sharedHeaders("SetUserPoolMfaConfig");
     let body;
     body = JSON.stringify(se_SetUserPoolMfaConfigRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SetUserPoolMfaConfigCommand = se_SetUserPoolMfaConfigCommand;
 const se_SetUserSettingsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.SetUserSettings",
-    };
+    const headers = sharedHeaders("SetUserSettings");
     let body;
     body = JSON.stringify(se_SetUserSettingsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SetUserSettingsCommand = se_SetUserSettingsCommand;
 const se_SignUpCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.SignUp",
-    };
+    const headers = sharedHeaders("SignUp");
     let body;
     body = JSON.stringify(se_SignUpRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_SignUpCommand = se_SignUpCommand;
 const se_StartUserImportJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.StartUserImportJob",
-    };
+    const headers = sharedHeaders("StartUserImportJob");
     let body;
     body = JSON.stringify(se_StartUserImportJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StartUserImportJobCommand = se_StartUserImportJobCommand;
 const se_StopUserImportJobCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.StopUserImportJob",
-    };
+    const headers = sharedHeaders("StopUserImportJob");
     let body;
     body = JSON.stringify(se_StopUserImportJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_StopUserImportJobCommand = se_StopUserImportJobCommand;
 const se_TagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.TagResource",
-    };
+    const headers = sharedHeaders("TagResource");
     let body;
     body = JSON.stringify(se_TagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_TagResourceCommand = se_TagResourceCommand;
 const se_UntagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UntagResource",
-    };
+    const headers = sharedHeaders("UntagResource");
     let body;
     body = JSON.stringify(se_UntagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UntagResourceCommand = se_UntagResourceCommand;
 const se_UpdateAuthEventFeedbackCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateAuthEventFeedback",
-    };
+    const headers = sharedHeaders("UpdateAuthEventFeedback");
     let body;
     body = JSON.stringify(se_UpdateAuthEventFeedbackRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateAuthEventFeedbackCommand = se_UpdateAuthEventFeedbackCommand;
 const se_UpdateDeviceStatusCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateDeviceStatus",
-    };
+    const headers = sharedHeaders("UpdateDeviceStatus");
     let body;
     body = JSON.stringify(se_UpdateDeviceStatusRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateDeviceStatusCommand = se_UpdateDeviceStatusCommand;
 const se_UpdateGroupCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateGroup",
-    };
+    const headers = sharedHeaders("UpdateGroup");
     let body;
     body = JSON.stringify(se_UpdateGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateGroupCommand = se_UpdateGroupCommand;
 const se_UpdateIdentityProviderCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateIdentityProvider",
-    };
+    const headers = sharedHeaders("UpdateIdentityProvider");
     let body;
     body = JSON.stringify(se_UpdateIdentityProviderRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateIdentityProviderCommand = se_UpdateIdentityProviderCommand;
 const se_UpdateResourceServerCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateResourceServer",
-    };
+    const headers = sharedHeaders("UpdateResourceServer");
     let body;
     body = JSON.stringify(se_UpdateResourceServerRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateResourceServerCommand = se_UpdateResourceServerCommand;
 const se_UpdateUserAttributesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateUserAttributes",
-    };
+    const headers = sharedHeaders("UpdateUserAttributes");
     let body;
     body = JSON.stringify(se_UpdateUserAttributesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateUserAttributesCommand = se_UpdateUserAttributesCommand;
 const se_UpdateUserPoolCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateUserPool",
-    };
+    const headers = sharedHeaders("UpdateUserPool");
     let body;
     body = JSON.stringify(se_UpdateUserPoolRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateUserPoolCommand = se_UpdateUserPoolCommand;
 const se_UpdateUserPoolClientCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateUserPoolClient",
-    };
+    const headers = sharedHeaders("UpdateUserPoolClient");
     let body;
     body = JSON.stringify(se_UpdateUserPoolClientRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateUserPoolClientCommand = se_UpdateUserPoolClientCommand;
 const se_UpdateUserPoolDomainCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.UpdateUserPoolDomain",
-    };
+    const headers = sharedHeaders("UpdateUserPoolDomain");
     let body;
     body = JSON.stringify(se_UpdateUserPoolDomainRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_UpdateUserPoolDomainCommand = se_UpdateUserPoolDomainCommand;
 const se_VerifySoftwareTokenCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.VerifySoftwareToken",
-    };
+    const headers = sharedHeaders("VerifySoftwareToken");
     let body;
     body = JSON.stringify(se_VerifySoftwareTokenRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 exports.se_VerifySoftwareTokenCommand = se_VerifySoftwareTokenCommand;
 const se_VerifyUserAttributeCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": "AWSCognitoIdentityProviderService.VerifyUserAttribute",
-    };
+    const headers = sharedHeaders("VerifyUserAttribute");
     let body;
     body = JSON.stringify(se_VerifyUserAttributeRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
@@ -10058,6 +9755,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": `AWSCognitoIdentityProviderService.${operation}`,
+    };
+}
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);