@rio-cloud/cdk-v2-constructs 6.11.0 → 6.12.0

package/node_modules/@aws-sdk/client-organizations/dist-es/protocols/Aws_json1_1.js

@@ -0,0 +1,1842 @@
+import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
+import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
+import { AccessDeniedException, AccessDeniedForDependencyException, AccountAlreadyClosedException, AccountAlreadyRegisteredException, AccountNotFoundException, AccountNotRegisteredException, AccountOwnerNotVerifiedException, AlreadyInOrganizationException, AWSOrganizationsNotInUseException, ChildNotFoundException, ConcurrentModificationException, ConflictException, ConstraintViolationException, CreateAccountStatusNotFoundException, DestinationParentNotFoundException, DuplicateAccountException, DuplicateHandshakeException, DuplicateOrganizationalUnitException, DuplicatePolicyAttachmentException, DuplicatePolicyException, EffectivePolicyNotFoundException, FinalizingOrganizationException, HandshakeAlreadyInStateException, HandshakeConstraintViolationException, HandshakeNotFoundException, InvalidHandshakeTransitionException, InvalidInputException, MalformedPolicyDocumentException, MasterCannotLeaveOrganizationException, OrganizationalUnitNotEmptyException, OrganizationalUnitNotFoundException, OrganizationNotEmptyException, ParentNotFoundException, PolicyChangesInProgressException, PolicyInUseException, PolicyNotAttachedException, PolicyNotFoundException, PolicyTypeAlreadyEnabledException, PolicyTypeNotAvailableForOrganizationException, PolicyTypeNotEnabledException, ResourcePolicyNotFoundException, RootNotFoundException, ServiceException, SourceParentNotFoundException, TargetNotFoundException, TooManyRequestsException, UnsupportedAPIEndpointException, } from "../models/models_0";
+import { OrganizationsServiceException as __BaseException } from "../models/OrganizationsServiceException";
+export const se_AcceptHandshakeCommand = async (input, context) => {
+    const headers = sharedHeaders("AcceptHandshake");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_AttachPolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("AttachPolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CancelHandshakeCommand = async (input, context) => {
+    const headers = sharedHeaders("CancelHandshake");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CloseAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("CloseAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CreateAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CreateGovCloudAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateGovCloudAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CreateOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateOrganization");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CreateOrganizationalUnitCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateOrganizationalUnit");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_CreatePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("CreatePolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DeclineHandshakeCommand = async (input, context) => {
+    const headers = sharedHeaders("DeclineHandshake");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DeleteOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteOrganization");
+    const body = "{}";
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DeleteOrganizationalUnitCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteOrganizationalUnit");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DeletePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DeletePolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DeleteResourcePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteResourcePolicy");
+    const body = "{}";
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DeregisterDelegatedAdministratorCommand = async (input, context) => {
+    const headers = sharedHeaders("DeregisterDelegatedAdministrator");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeCreateAccountStatusCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeCreateAccountStatus");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeEffectivePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeEffectivePolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeHandshakeCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeHandshake");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeOrganization");
+    const body = "{}";
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeOrganizationalUnitCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeOrganizationalUnit");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribePolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DescribeResourcePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeResourcePolicy");
+    const body = "{}";
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DetachPolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DetachPolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DisableAWSServiceAccessCommand = async (input, context) => {
+    const headers = sharedHeaders("DisableAWSServiceAccess");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_DisablePolicyTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("DisablePolicyType");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_EnableAllFeaturesCommand = async (input, context) => {
+    const headers = sharedHeaders("EnableAllFeatures");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_EnableAWSServiceAccessCommand = async (input, context) => {
+    const headers = sharedHeaders("EnableAWSServiceAccess");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_EnablePolicyTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("EnablePolicyType");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_InviteAccountToOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("InviteAccountToOrganization");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_LeaveOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("LeaveOrganization");
+    const body = "{}";
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListAccountsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListAccounts");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListAccountsForParentCommand = async (input, context) => {
+    const headers = sharedHeaders("ListAccountsForParent");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListAWSServiceAccessForOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("ListAWSServiceAccessForOrganization");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListChildrenCommand = async (input, context) => {
+    const headers = sharedHeaders("ListChildren");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListCreateAccountStatusCommand = async (input, context) => {
+    const headers = sharedHeaders("ListCreateAccountStatus");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListDelegatedAdministratorsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListDelegatedAdministrators");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListDelegatedServicesForAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("ListDelegatedServicesForAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListHandshakesForAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("ListHandshakesForAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListHandshakesForOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("ListHandshakesForOrganization");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListOrganizationalUnitsForParentCommand = async (input, context) => {
+    const headers = sharedHeaders("ListOrganizationalUnitsForParent");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListParentsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListParents");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListPoliciesCommand = async (input, context) => {
+    const headers = sharedHeaders("ListPolicies");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListPoliciesForTargetCommand = async (input, context) => {
+    const headers = sharedHeaders("ListPoliciesForTarget");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListRootsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListRoots");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListTagsForResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("ListTagsForResource");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_ListTargetsForPolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("ListTargetsForPolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_MoveAccountCommand = async (input, context) => {
+    const headers = sharedHeaders("MoveAccount");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_PutResourcePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("PutResourcePolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_RegisterDelegatedAdministratorCommand = async (input, context) => {
+    const headers = sharedHeaders("RegisterDelegatedAdministrator");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_RemoveAccountFromOrganizationCommand = async (input, context) => {
+    const headers = sharedHeaders("RemoveAccountFromOrganization");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_TagResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("TagResource");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_UntagResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("UntagResource");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_UpdateOrganizationalUnitCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateOrganizationalUnit");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const se_UpdatePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdatePolicy");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const de_AcceptHandshakeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_AcceptHandshakeResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_AttachPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_CancelHandshakeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_CancelHandshakeResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_CloseAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_CreateAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_CreateAccountResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_CreateGovCloudAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_CreateGovCloudAccountResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_CreateOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_CreateOrganizationalUnitCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_CreatePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DeclineHandshakeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DeclineHandshakeResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DeleteOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DeleteOrganizationalUnitCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DeletePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DeleteResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DeregisterDelegatedAdministratorCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DescribeAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeAccountResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribeCreateAccountStatusCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeCreateAccountStatusResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribeEffectivePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeEffectivePolicyResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribeHandshakeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeHandshakeResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribeOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribeOrganizationalUnitCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DescribeResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_DetachPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DisableAWSServiceAccessCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_DisablePolicyTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_EnableAllFeaturesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_EnableAllFeaturesResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_EnableAWSServiceAccessCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_EnablePolicyTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_InviteAccountToOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_InviteAccountToOrganizationResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_LeaveOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_ListAccountsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListAccountsResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListAccountsForParentCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListAccountsForParentResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListAWSServiceAccessForOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListAWSServiceAccessForOrganizationResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListChildrenCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListCreateAccountStatusCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListCreateAccountStatusResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListDelegatedAdministratorsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListDelegatedAdministratorsResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListDelegatedServicesForAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListDelegatedServicesForAccountResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListHandshakesForAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListHandshakesForAccountResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListHandshakesForOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListHandshakesForOrganizationResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListOrganizationalUnitsForParentCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListParentsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListPoliciesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListPoliciesForTargetCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListRootsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_ListTargetsForPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_MoveAccountCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_PutResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_RegisterDelegatedAdministratorCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_RemoveAccountFromOrganizationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+export const de_UpdateOrganizationalUnitCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+export const de_UpdatePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AWSOrganizationsNotInUseException":
+        case "com.amazonaws.organizations#AWSOrganizationsNotInUseException":
+            throw await de_AWSOrganizationsNotInUseExceptionRes(parsedOutput, context);
+        case "AccessDeniedException":
+        case "com.amazonaws.organizations#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "AccessDeniedForDependencyException":
+        case "com.amazonaws.organizations#AccessDeniedForDependencyException":
+            throw await de_AccessDeniedForDependencyExceptionRes(parsedOutput, context);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.organizations#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+        case "HandshakeAlreadyInStateException":
+        case "com.amazonaws.organizations#HandshakeAlreadyInStateException":
+            throw await de_HandshakeAlreadyInStateExceptionRes(parsedOutput, context);
+        case "HandshakeConstraintViolationException":
+        case "com.amazonaws.organizations#HandshakeConstraintViolationException":
+            throw await de_HandshakeConstraintViolationExceptionRes(parsedOutput, context);
+        case "HandshakeNotFoundException":
+        case "com.amazonaws.organizations#HandshakeNotFoundException":
+            throw await de_HandshakeNotFoundExceptionRes(parsedOutput, context);
+        case "InvalidHandshakeTransitionException":
+        case "com.amazonaws.organizations#InvalidHandshakeTransitionException":
+            throw await de_InvalidHandshakeTransitionExceptionRes(parsedOutput, context);
+        case "InvalidInputException":
+        case "com.amazonaws.organizations#InvalidInputException":
+            throw await de_InvalidInputExceptionRes(parsedOutput, context);
+        case "ServiceException":
+        case "com.amazonaws.organizations#ServiceException":
+            throw await de_ServiceExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.organizations#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "ConstraintViolationException":
+        case "com.amazonaws.organizations#ConstraintViolationException":
+            throw await de_ConstraintViolationExceptionRes(parsedOutput, context);
+        case "DuplicatePolicyAttachmentException":
+        case "com.amazonaws.organizations#DuplicatePolicyAttachmentException":
+            throw await de_DuplicatePolicyAttachmentExceptionRes(parsedOutput, context);
+        case "PolicyChangesInProgressException":
+        case "com.amazonaws.organizations#PolicyChangesInProgressException":
+            throw await de_PolicyChangesInProgressExceptionRes(parsedOutput, context);
+        case "PolicyNotFoundException":
+        case "com.amazonaws.organizations#PolicyNotFoundException":
+            throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
+        case "PolicyTypeNotEnabledException":
+        case "com.amazonaws.organizations#PolicyTypeNotEnabledException":
+            throw await de_PolicyTypeNotEnabledExceptionRes(parsedOutput, context);
+        case "TargetNotFoundException":
+        case "com.amazonaws.organizations#TargetNotFoundException":
+            throw await de_TargetNotFoundExceptionRes(parsedOutput, context);
+        case "UnsupportedAPIEndpointException":
+        case "com.amazonaws.organizations#UnsupportedAPIEndpointException":
+            throw await de_UnsupportedAPIEndpointExceptionRes(parsedOutput, context);
+        case "AccountAlreadyClosedException":
+        case "com.amazonaws.organizations#AccountAlreadyClosedException":
+            throw await de_AccountAlreadyClosedExceptionRes(parsedOutput, context);
+        case "AccountNotFoundException":
+        case "com.amazonaws.organizations#AccountNotFoundException":
+            throw await de_AccountNotFoundExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.organizations#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "FinalizingOrganizationException":
+        case "com.amazonaws.organizations#FinalizingOrganizationException":
+            throw await de_FinalizingOrganizationExceptionRes(parsedOutput, context);
+        case "AlreadyInOrganizationException":
+        case "com.amazonaws.organizations#AlreadyInOrganizationException":
+            throw await de_AlreadyInOrganizationExceptionRes(parsedOutput, context);
+        case "DuplicateOrganizationalUnitException":
+        case "com.amazonaws.organizations#DuplicateOrganizationalUnitException":
+            throw await de_DuplicateOrganizationalUnitExceptionRes(parsedOutput, context);
+        case "ParentNotFoundException":
+        case "com.amazonaws.organizations#ParentNotFoundException":
+            throw await de_ParentNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicatePolicyException":
+        case "com.amazonaws.organizations#DuplicatePolicyException":
+            throw await de_DuplicatePolicyExceptionRes(parsedOutput, context);
+        case "MalformedPolicyDocumentException":
+        case "com.amazonaws.organizations#MalformedPolicyDocumentException":
+            throw await de_MalformedPolicyDocumentExceptionRes(parsedOutput, context);
+        case "PolicyTypeNotAvailableForOrganizationException":
+        case "com.amazonaws.organizations#PolicyTypeNotAvailableForOrganizationException":
+            throw await de_PolicyTypeNotAvailableForOrganizationExceptionRes(parsedOutput, context);
+        case "OrganizationNotEmptyException":
+        case "com.amazonaws.organizations#OrganizationNotEmptyException":
+            throw await de_OrganizationNotEmptyExceptionRes(parsedOutput, context);
+        case "OrganizationalUnitNotEmptyException":
+        case "com.amazonaws.organizations#OrganizationalUnitNotEmptyException":
+            throw await de_OrganizationalUnitNotEmptyExceptionRes(parsedOutput, context);
+        case "OrganizationalUnitNotFoundException":
+        case "com.amazonaws.organizations#OrganizationalUnitNotFoundException":
+            throw await de_OrganizationalUnitNotFoundExceptionRes(parsedOutput, context);
+        case "PolicyInUseException":
+        case "com.amazonaws.organizations#PolicyInUseException":
+            throw await de_PolicyInUseExceptionRes(parsedOutput, context);
+        case "ResourcePolicyNotFoundException":
+        case "com.amazonaws.organizations#ResourcePolicyNotFoundException":
+            throw await de_ResourcePolicyNotFoundExceptionRes(parsedOutput, context);
+        case "AccountNotRegisteredException":
+        case "com.amazonaws.organizations#AccountNotRegisteredException":
+            throw await de_AccountNotRegisteredExceptionRes(parsedOutput, context);
+        case "CreateAccountStatusNotFoundException":
+        case "com.amazonaws.organizations#CreateAccountStatusNotFoundException":
+            throw await de_CreateAccountStatusNotFoundExceptionRes(parsedOutput, context);
+        case "EffectivePolicyNotFoundException":
+        case "com.amazonaws.organizations#EffectivePolicyNotFoundException":
+            throw await de_EffectivePolicyNotFoundExceptionRes(parsedOutput, context);
+        case "PolicyNotAttachedException":
+        case "com.amazonaws.organizations#PolicyNotAttachedException":
+            throw await de_PolicyNotAttachedExceptionRes(parsedOutput, context);
+        case "RootNotFoundException":
+        case "com.amazonaws.organizations#RootNotFoundException":
+            throw await de_RootNotFoundExceptionRes(parsedOutput, context);
+        case "PolicyTypeAlreadyEnabledException":
+        case "com.amazonaws.organizations#PolicyTypeAlreadyEnabledException":
+            throw await de_PolicyTypeAlreadyEnabledExceptionRes(parsedOutput, context);
+        case "AccountOwnerNotVerifiedException":
+        case "com.amazonaws.organizations#AccountOwnerNotVerifiedException":
+            throw await de_AccountOwnerNotVerifiedExceptionRes(parsedOutput, context);
+        case "DuplicateHandshakeException":
+        case "com.amazonaws.organizations#DuplicateHandshakeException":
+            throw await de_DuplicateHandshakeExceptionRes(parsedOutput, context);
+        case "MasterCannotLeaveOrganizationException":
+        case "com.amazonaws.organizations#MasterCannotLeaveOrganizationException":
+            throw await de_MasterCannotLeaveOrganizationExceptionRes(parsedOutput, context);
+        case "ChildNotFoundException":
+        case "com.amazonaws.organizations#ChildNotFoundException":
+            throw await de_ChildNotFoundExceptionRes(parsedOutput, context);
+        case "DestinationParentNotFoundException":
+        case "com.amazonaws.organizations#DestinationParentNotFoundException":
+            throw await de_DestinationParentNotFoundExceptionRes(parsedOutput, context);
+        case "DuplicateAccountException":
+        case "com.amazonaws.organizations#DuplicateAccountException":
+            throw await de_DuplicateAccountExceptionRes(parsedOutput, context);
+        case "SourceParentNotFoundException":
+        case "com.amazonaws.organizations#SourceParentNotFoundException":
+            throw await de_SourceParentNotFoundExceptionRes(parsedOutput, context);
+        case "AccountAlreadyRegisteredException":
+        case "com.amazonaws.organizations#AccountAlreadyRegisteredException":
+            throw await de_AccountAlreadyRegisteredExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AccessDeniedForDependencyExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccessDeniedForDependencyException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AccountAlreadyClosedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccountAlreadyClosedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AccountAlreadyRegisteredExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccountAlreadyRegisteredException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AccountNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccountNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AccountNotRegisteredExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccountNotRegisteredException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AccountOwnerNotVerifiedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AccountOwnerNotVerifiedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AlreadyInOrganizationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AlreadyInOrganizationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AWSOrganizationsNotInUseExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new AWSOrganizationsNotInUseException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ChildNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ChildNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ConstraintViolationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ConstraintViolationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_CreateAccountStatusNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new CreateAccountStatusNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_DestinationParentNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DestinationParentNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_DuplicateAccountExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DuplicateAccountException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_DuplicateHandshakeExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DuplicateHandshakeException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_DuplicateOrganizationalUnitExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DuplicateOrganizationalUnitException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_DuplicatePolicyAttachmentExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DuplicatePolicyAttachmentException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_DuplicatePolicyExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new DuplicatePolicyException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_EffectivePolicyNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new EffectivePolicyNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_FinalizingOrganizationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new FinalizingOrganizationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_HandshakeAlreadyInStateExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new HandshakeAlreadyInStateException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_HandshakeConstraintViolationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new HandshakeConstraintViolationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_HandshakeNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new HandshakeNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_InvalidHandshakeTransitionExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new InvalidHandshakeTransitionException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_InvalidInputExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new InvalidInputException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_MalformedPolicyDocumentExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new MalformedPolicyDocumentException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_MasterCannotLeaveOrganizationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new MasterCannotLeaveOrganizationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_OrganizationalUnitNotEmptyExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new OrganizationalUnitNotEmptyException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_OrganizationalUnitNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new OrganizationalUnitNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_OrganizationNotEmptyExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new OrganizationNotEmptyException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ParentNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ParentNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyChangesInProgressExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyChangesInProgressException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyInUseExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyInUseException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyNotAttachedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyNotAttachedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyTypeAlreadyEnabledExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyTypeAlreadyEnabledException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyTypeNotAvailableForOrganizationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyTypeNotAvailableForOrganizationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_PolicyTypeNotEnabledExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new PolicyTypeNotEnabledException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ResourcePolicyNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ResourcePolicyNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_RootNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new RootNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_ServiceExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ServiceException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_SourceParentNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new SourceParentNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_TargetNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new TargetNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new TooManyRequestsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_UnsupportedAPIEndpointExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new UnsupportedAPIEndpointException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const de_AcceptHandshakeResponse = (output, context) => {
+    return take(output, {
+        Handshake: (_) => de_Handshake(_, context),
+    });
+};
+const de_Account = (output, context) => {
+    return take(output, {
+        Arn: __expectString,
+        Email: __expectString,
+        Id: __expectString,
+        JoinedMethod: __expectString,
+        JoinedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Name: __expectString,
+        Status: __expectString,
+    });
+};
+const de_Accounts = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Account(entry, context);
+    });
+    return retVal;
+};
+const de_CancelHandshakeResponse = (output, context) => {
+    return take(output, {
+        Handshake: (_) => de_Handshake(_, context),
+    });
+};
+const de_CreateAccountResponse = (output, context) => {
+    return take(output, {
+        CreateAccountStatus: (_) => de_CreateAccountStatus(_, context),
+    });
+};
+const de_CreateAccountStatus = (output, context) => {
+    return take(output, {
+        AccountId: __expectString,
+        AccountName: __expectString,
+        CompletedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        FailureReason: __expectString,
+        GovCloudAccountId: __expectString,
+        Id: __expectString,
+        RequestedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        State: __expectString,
+    });
+};
+const de_CreateAccountStatuses = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_CreateAccountStatus(entry, context);
+    });
+    return retVal;
+};
+const de_CreateGovCloudAccountResponse = (output, context) => {
+    return take(output, {
+        CreateAccountStatus: (_) => de_CreateAccountStatus(_, context),
+    });
+};
+const de_DeclineHandshakeResponse = (output, context) => {
+    return take(output, {
+        Handshake: (_) => de_Handshake(_, context),
+    });
+};
+const de_DelegatedAdministrator = (output, context) => {
+    return take(output, {
+        Arn: __expectString,
+        DelegationEnabledDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Email: __expectString,
+        Id: __expectString,
+        JoinedMethod: __expectString,
+        JoinedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Name: __expectString,
+        Status: __expectString,
+    });
+};
+const de_DelegatedAdministrators = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_DelegatedAdministrator(entry, context);
+    });
+    return retVal;
+};
+const de_DelegatedService = (output, context) => {
+    return take(output, {
+        DelegationEnabledDate: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        ServicePrincipal: __expectString,
+    });
+};
+const de_DelegatedServices = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_DelegatedService(entry, context);
+    });
+    return retVal;
+};
+const de_DescribeAccountResponse = (output, context) => {
+    return take(output, {
+        Account: (_) => de_Account(_, context),
+    });
+};
+const de_DescribeCreateAccountStatusResponse = (output, context) => {
+    return take(output, {
+        CreateAccountStatus: (_) => de_CreateAccountStatus(_, context),
+    });
+};
+const de_DescribeEffectivePolicyResponse = (output, context) => {
+    return take(output, {
+        EffectivePolicy: (_) => de_EffectivePolicy(_, context),
+    });
+};
+const de_DescribeHandshakeResponse = (output, context) => {
+    return take(output, {
+        Handshake: (_) => de_Handshake(_, context),
+    });
+};
+const de_EffectivePolicy = (output, context) => {
+    return take(output, {
+        LastUpdatedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        PolicyContent: __expectString,
+        PolicyType: __expectString,
+        TargetId: __expectString,
+    });
+};
+const de_EnableAllFeaturesResponse = (output, context) => {
+    return take(output, {
+        Handshake: (_) => de_Handshake(_, context),
+    });
+};
+const de_EnabledServicePrincipal = (output, context) => {
+    return take(output, {
+        DateEnabled: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        ServicePrincipal: __expectString,
+    });
+};
+const de_EnabledServicePrincipals = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_EnabledServicePrincipal(entry, context);
+    });
+    return retVal;
+};
+const de_Handshake = (output, context) => {
+    return take(output, {
+        Action: __expectString,
+        Arn: __expectString,
+        ExpirationTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Id: __expectString,
+        Parties: _json,
+        RequestedTimestamp: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        Resources: (_) => de_HandshakeResources(_, context),
+        State: __expectString,
+    });
+};
+const de_HandshakeResource = (output, context) => {
+    return take(output, {
+        Resources: (_) => de_HandshakeResources(_, context),
+        Type: __expectString,
+        Value: __expectString,
+    });
+};
+const de_HandshakeResources = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_HandshakeResource(entry, context);
+    });
+    return retVal;
+};
+const de_Handshakes = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Handshake(entry, context);
+    });
+    return retVal;
+};
+const de_InviteAccountToOrganizationResponse = (output, context) => {
+    return take(output, {
+        Handshake: (_) => de_Handshake(_, context),
+    });
+};
+const de_ListAccountsForParentResponse = (output, context) => {
+    return take(output, {
+        Accounts: (_) => de_Accounts(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListAccountsResponse = (output, context) => {
+    return take(output, {
+        Accounts: (_) => de_Accounts(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListAWSServiceAccessForOrganizationResponse = (output, context) => {
+    return take(output, {
+        EnabledServicePrincipals: (_) => de_EnabledServicePrincipals(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListCreateAccountStatusResponse = (output, context) => {
+    return take(output, {
+        CreateAccountStatuses: (_) => de_CreateAccountStatuses(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListDelegatedAdministratorsResponse = (output, context) => {
+    return take(output, {
+        DelegatedAdministrators: (_) => de_DelegatedAdministrators(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListDelegatedServicesForAccountResponse = (output, context) => {
+    return take(output, {
+        DelegatedServices: (_) => de_DelegatedServices(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListHandshakesForAccountResponse = (output, context) => {
+    return take(output, {
+        Handshakes: (_) => de_Handshakes(_, context),
+        NextToken: __expectString,
+    });
+};
+const de_ListHandshakesForOrganizationResponse = (output, context) => {
+    return take(output, {
+        Handshakes: (_) => de_Handshakes(_, context),
+        NextToken: __expectString,
+    });
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const throwDefaultError = withBaseException(__BaseException);
+const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const contents = {
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+        headers,
+    };
+    if (resolvedHostname !== undefined) {
+        contents.hostname = resolvedHostname;
+    }
+    if (body !== undefined) {
+        contents.body = body;
+    }
+    return new __HttpRequest(contents);
+};
+function sharedHeaders(operation) {
+    return {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": `AWSOrganizationsV20161128.${operation}`,
+    };
+}