npm - @aws-sdk/client-directory-service - Versions diffs - 3.504.0 → 3.509.0 - Mend

@aws-sdk/client-directory-service 3.504.0 → 3.509.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist-cjs/index.js +201 -2265
package/dist-es/protocols/Aws_json1_1.js +435 -2499
package/package.json +3 -3

package/dist-es/protocols/Aws_json1_1.js CHANGED Viewed

@@ -406,7 +406,7 @@ export const se_VerifyTrustCommand = async (input, context) => {
 };
 export const de_AcceptSharedDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AcceptSharedDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -417,40 +417,9 @@ export const de_AcceptSharedDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_AcceptSharedDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryAlreadySharedException":
-        case "com.amazonaws.directoryservice#DirectoryAlreadySharedException":
-            throw await de_DirectoryAlreadySharedExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_AddIpRoutesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddIpRoutesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -461,46 +430,9 @@ export const de_AddIpRoutesCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddIpRoutesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "IpRouteLimitExceededException":
-        case "com.amazonaws.directoryservice#IpRouteLimitExceededException":
-            throw await de_IpRouteLimitExceededExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_AddRegionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddRegionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -511,55 +443,9 @@ export const de_AddRegionCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddRegionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryAlreadyInRegionException":
-        case "com.amazonaws.directoryservice#DirectoryAlreadyInRegionException":
-            throw await de_DirectoryAlreadyInRegionExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "RegionLimitExceededException":
-        case "com.amazonaws.directoryservice#RegionLimitExceededException":
-            throw await de_RegionLimitExceededExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_AddTagsToResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_AddTagsToResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -570,40 +456,9 @@ export const de_AddTagsToResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_AddTagsToResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "TagLimitExceededException":
-        case "com.amazonaws.directoryservice#TagLimitExceededException":
-            throw await de_TagLimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CancelSchemaExtensionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CancelSchemaExtensionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -614,34 +469,9 @@ export const de_CancelSchemaExtensionCommand = async (output, context) => {
     };
     return response;
 };
-const de_CancelSchemaExtensionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_ConnectDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ConnectDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -652,37 +482,9 @@ export const de_ConnectDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_ConnectDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryLimitExceededException":
-        case "com.amazonaws.directoryservice#DirectoryLimitExceededException":
-            throw await de_DirectoryLimitExceededExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_CreateAliasCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateAliasCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -693,40 +495,35 @@ export const de_CreateAliasCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateAliasCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_CreateComputerCommand = 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,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    return response;
+};
+export const de_CreateConditionalForwarderCommand = 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_CreateComputerCommand = async (output, context) => {
+export const de_CreateDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateComputerCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -737,49 +534,22 @@ export const de_CreateComputerCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateComputerCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_CreateLogSubscriptionCommand = 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,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AuthenticationFailedException":
-        case "com.amazonaws.directoryservice#AuthenticationFailedException":
-            throw await de_AuthenticationFailedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    return response;
 };
-export const de_CreateConditionalForwarderCommand = async (output, context) => {
+export const de_CreateMicrosoftADCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateConditionalForwarderCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -790,46 +560,9 @@ export const de_CreateConditionalForwarderCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateConditionalForwarderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateDirectoryCommand = async (output, context) => {
+export const de_CreateSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -840,37 +573,9 @@ export const de_CreateDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryLimitExceededException":
-        case "com.amazonaws.directoryservice#DirectoryLimitExceededException":
-            throw await de_DirectoryLimitExceededExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateLogSubscriptionCommand = async (output, context) => {
+export const de_CreateTrustCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateLogSubscriptionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -881,43 +586,9 @@ export const de_CreateLogSubscriptionCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateLogSubscriptionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InsufficientPermissionsException":
-        case "com.amazonaws.directoryservice#InsufficientPermissionsException":
-            throw await de_InsufficientPermissionsExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateMicrosoftADCommand = async (output, context) => {
+export const de_DeleteConditionalForwarderCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateMicrosoftADCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -928,40 +599,9 @@ export const de_CreateMicrosoftADCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateMicrosoftADCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryLimitExceededException":
-        case "com.amazonaws.directoryservice#DirectoryLimitExceededException":
-            throw await de_DirectoryLimitExceededExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_CreateSnapshotCommand = async (output, context) => {
+export const de_DeleteDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -972,40 +612,22 @@ export const de_CreateSnapshotCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "SnapshotLimitExceededException":
-        case "com.amazonaws.directoryservice#SnapshotLimitExceededException":
-            throw await de_SnapshotLimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteLogSubscriptionCommand = 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_CreateTrustCommand = async (output, context) => {
+export const de_DeleteSnapshotCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_CreateTrustCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1016,43 +638,22 @@ export const de_CreateTrustCommand = async (output, context) => {
     };
     return response;
 };
-const de_CreateTrustCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DeleteTrustCommand = 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_DeleteConditionalForwarderCommand = async (output, context) => {
+export const de_DeregisterCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteConditionalForwarderCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1063,43 +664,9 @@ export const de_DeleteConditionalForwarderCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteConditionalForwarderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteDirectoryCommand = async (output, context) => {
+export const de_DeregisterEventTopicCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1110,116 +677,35 @@ export const de_DeleteDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteLogSubscriptionCommand = async (output, context) => {
+export const de_DescribeCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteLogSubscriptionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_DescribeCertificateResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeleteLogSubscriptionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteSnapshotCommand = async (output, context) => {
+export const de_DescribeClientAuthenticationSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_DescribeClientAuthenticationSettingsResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeleteSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DeleteTrustCommand = async (output, context) => {
+export const de_DescribeConditionalForwardersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeleteTrustCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -1230,1355 +716,139 @@ export const de_DeleteTrustCommand = async (output, context) => {
     };
     return response;
 };
-const de_DeleteTrustCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeDirectoriesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeDirectoriesResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeregisterCertificateCommand = async (output, context) => {
+export const de_DescribeDomainControllersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeregisterCertificateCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_DescribeDomainControllersResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeregisterCertificateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CertificateDoesNotExistException":
-        case "com.amazonaws.directoryservice#CertificateDoesNotExistException":
-            throw await de_CertificateDoesNotExistExceptionRes(parsedOutput, context);
-        case "CertificateInUseException":
-        case "com.amazonaws.directoryservice#CertificateInUseException":
-            throw await de_CertificateInUseExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeEventTopicsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeEventTopicsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DeregisterEventTopicCommand = async (output, context) => {
+export const de_DescribeLDAPSSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DeregisterEventTopicCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_DescribeLDAPSSettingsResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DeregisterEventTopicCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_DescribeRegionsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeRegionsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_DescribeCertificateCommand = async (output, context) => {
+export const de_DescribeSettingsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_DescribeCertificateCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_DescribeCertificateResult(data, context);
+    contents = de_DescribeSettingsResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_DescribeCertificateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CertificateDoesNotExistException":
-        case "com.amazonaws.directoryservice#CertificateDoesNotExistException":
-            throw await de_CertificateDoesNotExistExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeClientAuthenticationSettingsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeClientAuthenticationSettingsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeClientAuthenticationSettingsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeClientAuthenticationSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeConditionalForwardersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeConditionalForwardersCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeConditionalForwardersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeDirectoriesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeDirectoriesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeDirectoriesResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeDirectoriesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeDomainControllersCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeDomainControllersCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeDomainControllersResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeDomainControllersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeEventTopicsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeEventTopicsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeEventTopicsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeEventTopicsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeLDAPSSettingsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeLDAPSSettingsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeLDAPSSettingsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeLDAPSSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeRegionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeRegionsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeRegionsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeRegionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeSettingsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeSettingsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeSettingsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeSharedDirectoriesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeSharedDirectoriesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeSharedDirectoriesResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeSharedDirectoriesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeSnapshotsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeSnapshotsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeSnapshotsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeSnapshotsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeTrustsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeTrustsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeTrustsResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeTrustsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DescribeUpdateDirectoryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DescribeUpdateDirectoryCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeUpdateDirectoryResult(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeUpdateDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DisableClientAuthenticationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DisableClientAuthenticationCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DisableClientAuthenticationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidClientAuthStatusException":
-        case "com.amazonaws.directoryservice#InvalidClientAuthStatusException":
-            throw await de_InvalidClientAuthStatusExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DisableLDAPSCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DisableLDAPSCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DisableLDAPSCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "InvalidLDAPSStatusException":
-        case "com.amazonaws.directoryservice#InvalidLDAPSStatusException":
-            throw await de_InvalidLDAPSStatusExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DisableRadiusCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DisableRadiusCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DisableRadiusCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_DisableSsoCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_DisableSsoCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DisableSsoCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AuthenticationFailedException":
-        case "com.amazonaws.directoryservice#AuthenticationFailedException":
-            throw await de_AuthenticationFailedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InsufficientPermissionsException":
-        case "com.amazonaws.directoryservice#InsufficientPermissionsException":
-            throw await de_InsufficientPermissionsExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_EnableClientAuthenticationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_EnableClientAuthenticationCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_EnableClientAuthenticationCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidClientAuthStatusException":
-        case "com.amazonaws.directoryservice#InvalidClientAuthStatusException":
-            throw await de_InvalidClientAuthStatusExceptionRes(parsedOutput, context);
-        case "NoAvailableCertificateException":
-        case "com.amazonaws.directoryservice#NoAvailableCertificateException":
-            throw await de_NoAvailableCertificateExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_EnableLDAPSCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_EnableLDAPSCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_EnableLDAPSCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "InvalidLDAPSStatusException":
-        case "com.amazonaws.directoryservice#InvalidLDAPSStatusException":
-            throw await de_InvalidLDAPSStatusExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "NoAvailableCertificateException":
-        case "com.amazonaws.directoryservice#NoAvailableCertificateException":
-            throw await de_NoAvailableCertificateExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_EnableRadiusCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_EnableRadiusCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_EnableRadiusCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityAlreadyExistsException":
-        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
-            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_EnableSsoCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_EnableSsoCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_EnableSsoCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AuthenticationFailedException":
-        case "com.amazonaws.directoryservice#AuthenticationFailedException":
-            throw await de_AuthenticationFailedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InsufficientPermissionsException":
-        case "com.amazonaws.directoryservice#InsufficientPermissionsException":
-            throw await de_InsufficientPermissionsExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetDirectoryLimitsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_GetDirectoryLimitsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetDirectoryLimitsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_GetSnapshotLimitsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_GetSnapshotLimitsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = _json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetSnapshotLimitsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListCertificatesCommand = async (output, context) => {
+export const de_DescribeSharedDirectoriesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListCertificatesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ListCertificatesResult(data, context);
+    contents = de_DescribeSharedDirectoriesResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ListCertificatesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListIpRoutesCommand = async (output, context) => {
+export const de_DescribeSnapshotsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListIpRoutesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ListIpRoutesResult(data, context);
+    contents = de_DescribeSnapshotsResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ListIpRoutesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListLogSubscriptionsCommand = async (output, context) => {
+export const de_DescribeTrustsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListLogSubscriptionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ListLogSubscriptionsResult(data, context);
+    contents = de_DescribeTrustsResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ListLogSubscriptionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListSchemaExtensionsCommand = async (output, context) => {
+export const de_DescribeUpdateDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListSchemaExtensionsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = de_ListSchemaExtensionsResult(data, context);
+    contents = de_DescribeUpdateDirectoryResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ListSchemaExtensionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ListTagsForResourceCommand = async (output, context) => {
+export const de_DisableClientAuthenticationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ListTagsForResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2589,40 +859,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.directoryservice#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_RegisterCertificateCommand = async (output, context) => {
+export const de_DisableLDAPSCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RegisterCertificateCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2630,55 +869,12 @@ export const de_RegisterCertificateCommand = async (output, context) => {
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
-    };
-    return response;
-};
-const de_RegisterCertificateCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "CertificateAlreadyExistsException":
-        case "com.amazonaws.directoryservice#CertificateAlreadyExistsException":
-            throw await de_CertificateAlreadyExistsExceptionRes(parsedOutput, context);
-        case "CertificateLimitExceededException":
-        case "com.amazonaws.directoryservice#CertificateLimitExceededException":
-            throw await de_CertificateLimitExceededExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "InvalidCertificateException":
-        case "com.amazonaws.directoryservice#InvalidCertificateException":
-            throw await de_InvalidCertificateExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
+    };
+    return response;
 };
-export const de_RegisterEventTopicCommand = async (output, context) => {
+export const de_DisableRadiusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RegisterEventTopicCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2689,37 +885,9 @@ export const de_RegisterEventTopicCommand = async (output, context) => {
     };
     return response;
 };
-const de_RegisterEventTopicCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_RejectSharedDirectoryCommand = async (output, context) => {
+export const de_DisableSsoCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RejectSharedDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2730,40 +898,22 @@ export const de_RejectSharedDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_RejectSharedDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryAlreadySharedException":
-        case "com.amazonaws.directoryservice#DirectoryAlreadySharedException":
-            throw await de_DirectoryAlreadySharedExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_EnableClientAuthenticationCommand = 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_RemoveIpRoutesCommand = async (output, context) => {
+export const de_EnableLDAPSCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RemoveIpRoutesCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2774,40 +924,22 @@ export const de_RemoveIpRoutesCommand = async (output, context) => {
     };
     return response;
 };
-const de_RemoveIpRoutesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_EnableRadiusCommand = 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_RemoveRegionCommand = async (output, context) => {
+export const de_EnableSsoCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RemoveRegionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2818,43 +950,22 @@ export const de_RemoveRegionCommand = async (output, context) => {
     };
     return response;
 };
-const de_RemoveRegionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_GetDirectoryLimitsCommand = 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_RemoveTagsFromResourceCommand = async (output, context) => {
+export const de_GetSnapshotLimitsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RemoveTagsFromResourceCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2865,87 +976,74 @@ export const de_RemoveTagsFromResourceCommand = async (output, context) => {
     };
     return response;
 };
-const de_RemoveTagsFromResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_ListCertificatesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListCertificatesResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    return response;
+};
+export const de_ListIpRoutesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
     }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListIpRoutesResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
 };
-export const de_ResetUserPasswordCommand = async (output, context) => {
+export const de_ListLogSubscriptionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ResetUserPasswordCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = _json(data);
+    contents = de_ListLogSubscriptionsResult(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return response;
 };
-const de_ResetUserPasswordCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
+export const de_ListSchemaExtensionsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = de_ListSchemaExtensionsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
     };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidPasswordException":
-        case "com.amazonaws.directoryservice#InvalidPasswordException":
-            throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        case "UserDoesNotExistException":
-        case "com.amazonaws.directoryservice#UserDoesNotExistException":
-            throw await de_UserDoesNotExistExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+    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_RestoreFromSnapshotCommand = async (output, context) => {
+export const de_RegisterCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_RestoreFromSnapshotCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2956,37 +1054,9 @@ export const de_RestoreFromSnapshotCommand = async (output, context) => {
     };
     return response;
 };
-const de_RestoreFromSnapshotCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_ShareDirectoryCommand = async (output, context) => {
+export const de_RegisterEventTopicCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_ShareDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -2997,55 +1067,9 @@ export const de_ShareDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_ShareDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryAlreadySharedException":
-        case "com.amazonaws.directoryservice#DirectoryAlreadySharedException":
-            throw await de_DirectoryAlreadySharedExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "InvalidTargetException":
-        case "com.amazonaws.directoryservice#InvalidTargetException":
-            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
-        case "OrganizationsException":
-        case "com.amazonaws.directoryservice#OrganizationsException":
-            throw await de_OrganizationsExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "ShareLimitExceededException":
-        case "com.amazonaws.directoryservice#ShareLimitExceededException":
-            throw await de_ShareLimitExceededExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-export const de_StartSchemaExtensionCommand = async (output, context) => {
+export const de_RejectSharedDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_StartSchemaExtensionCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3056,43 +1080,22 @@ export const de_StartSchemaExtensionCommand = async (output, context) => {
     };
     return response;
 };
-const de_StartSchemaExtensionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "SnapshotLimitExceededException":
-        case "com.amazonaws.directoryservice#SnapshotLimitExceededException":
-            throw await de_SnapshotLimitExceededExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_RemoveIpRoutesCommand = 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_UnshareDirectoryCommand = async (output, context) => {
+export const de_RemoveRegionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UnshareDirectoryCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3103,40 +1106,22 @@ export const de_UnshareDirectoryCommand = async (output, context) => {
     };
     return response;
 };
-const de_UnshareDirectoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryNotSharedException":
-        case "com.amazonaws.directoryservice#DirectoryNotSharedException":
-            throw await de_DirectoryNotSharedExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidTargetException":
-        case "com.amazonaws.directoryservice#InvalidTargetException":
-            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_RemoveTagsFromResourceCommand = 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_UpdateConditionalForwarderCommand = async (output, context) => {
+export const de_ResetUserPasswordCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateConditionalForwarderCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3147,43 +1132,22 @@ export const de_UpdateConditionalForwarderCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateConditionalForwarderCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_RestoreFromSnapshotCommand = 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_UpdateDirectorySetupCommand = async (output, context) => {
+export const de_ShareDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateDirectorySetupCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3194,52 +1158,22 @@ export const de_UpdateDirectorySetupCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateDirectorySetupCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.directoryservice#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryInDesiredStateException":
-        case "com.amazonaws.directoryservice#DirectoryInDesiredStateException":
-            throw await de_DirectoryInDesiredStateExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "SnapshotLimitExceededException":
-        case "com.amazonaws.directoryservice#SnapshotLimitExceededException":
-            throw await de_SnapshotLimitExceededExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_StartSchemaExtensionCommand = 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_UpdateNumberOfDomainControllersCommand = async (output, context) => {
+export const de_UnshareDirectoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateNumberOfDomainControllersCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3250,46 +1184,22 @@ export const de_UpdateNumberOfDomainControllersCommand = async (output, context)
     };
     return response;
 };
-const de_UpdateNumberOfDomainControllersCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "DomainControllerLimitExceededException":
-        case "com.amazonaws.directoryservice#DomainControllerLimitExceededException":
-            throw await de_DomainControllerLimitExceededExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateConditionalForwarderCommand = 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_UpdateRadiusCommand = async (output, context) => {
+export const de_UpdateDirectorySetupCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateRadiusCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3300,37 +1210,22 @@ export const de_UpdateRadiusCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateRadiusCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateNumberOfDomainControllersCommand = 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_UpdateSettingsCommand = async (output, context) => {
+export const de_UpdateRadiusCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateSettingsCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3341,49 +1236,22 @@ export const de_UpdateSettingsCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateSettingsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "DirectoryDoesNotExistException":
-        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
-            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
-        case "DirectoryUnavailableException":
-        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
-            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
-        case "IncompatibleSettingsException":
-        case "com.amazonaws.directoryservice#IncompatibleSettingsException":
-            throw await de_IncompatibleSettingsExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.directoryservice#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
-        case "UnsupportedSettingsException":
-        case "com.amazonaws.directoryservice#UnsupportedSettingsException":
-            throw await de_UnsupportedSettingsExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
+export const de_UpdateSettingsCommand = 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_UpdateTrustCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_UpdateTrustCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3394,37 +1262,9 @@ export const de_UpdateTrustCommand = async (output, context) => {
     };
     return response;
 };
-const de_UpdateTrustCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ClientException":
-        case "com.amazonaws.directoryservice#ClientException":
-            throw await de_ClientExceptionRes(parsedOutput, context);
-        case "EntityDoesNotExistException":
-        case "com.amazonaws.directoryservice#EntityDoesNotExistException":
-            throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
-        case "InvalidParameterException":
-        case "com.amazonaws.directoryservice#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-        case "ServiceException":
-        case "com.amazonaws.directoryservice#ServiceException":
-            throw await de_ServiceExceptionRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
 export const de_VerifyTrustCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return de_VerifyTrustCommandError(output, context);
+        return de_CommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
@@ -3435,7 +1275,7 @@ export const de_VerifyTrustCommand = async (output, context) => {
     };
     return response;
 };
-const de_VerifyTrustCommandError = async (output, context) => {
+const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3445,6 +1285,9 @@ const de_VerifyTrustCommandError = async (output, context) => {
         case "ClientException":
         case "com.amazonaws.directoryservice#ClientException":
             throw await de_ClientExceptionRes(parsedOutput, context);
+        case "DirectoryAlreadySharedException":
+        case "com.amazonaws.directoryservice#DirectoryAlreadySharedException":
+            throw await de_DirectoryAlreadySharedExceptionRes(parsedOutput, context);
         case "EntityDoesNotExistException":
         case "com.amazonaws.directoryservice#EntityDoesNotExistException":
             throw await de_EntityDoesNotExistExceptionRes(parsedOutput, context);
@@ -3454,9 +1297,102 @@ const de_VerifyTrustCommandError = async (output, context) => {
         case "ServiceException":
         case "com.amazonaws.directoryservice#ServiceException":
             throw await de_ServiceExceptionRes(parsedOutput, context);
+        case "DirectoryUnavailableException":
+        case "com.amazonaws.directoryservice#DirectoryUnavailableException":
+            throw await de_DirectoryUnavailableExceptionRes(parsedOutput, context);
+        case "EntityAlreadyExistsException":
+        case "com.amazonaws.directoryservice#EntityAlreadyExistsException":
+            throw await de_EntityAlreadyExistsExceptionRes(parsedOutput, context);
+        case "IpRouteLimitExceededException":
+        case "com.amazonaws.directoryservice#IpRouteLimitExceededException":
+            throw await de_IpRouteLimitExceededExceptionRes(parsedOutput, context);
+        case "AccessDeniedException":
+        case "com.amazonaws.directoryservice#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "DirectoryAlreadyInRegionException":
+        case "com.amazonaws.directoryservice#DirectoryAlreadyInRegionException":
+            throw await de_DirectoryAlreadyInRegionExceptionRes(parsedOutput, context);
+        case "DirectoryDoesNotExistException":
+        case "com.amazonaws.directoryservice#DirectoryDoesNotExistException":
+            throw await de_DirectoryDoesNotExistExceptionRes(parsedOutput, context);
+        case "RegionLimitExceededException":
+        case "com.amazonaws.directoryservice#RegionLimitExceededException":
+            throw await de_RegionLimitExceededExceptionRes(parsedOutput, context);
         case "UnsupportedOperationException":
         case "com.amazonaws.directoryservice#UnsupportedOperationException":
             throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+        case "TagLimitExceededException":
+        case "com.amazonaws.directoryservice#TagLimitExceededException":
+            throw await de_TagLimitExceededExceptionRes(parsedOutput, context);
+        case "DirectoryLimitExceededException":
+        case "com.amazonaws.directoryservice#DirectoryLimitExceededException":
+            throw await de_DirectoryLimitExceededExceptionRes(parsedOutput, context);
+        case "AuthenticationFailedException":
+        case "com.amazonaws.directoryservice#AuthenticationFailedException":
+            throw await de_AuthenticationFailedExceptionRes(parsedOutput, context);
+        case "InsufficientPermissionsException":
+        case "com.amazonaws.directoryservice#InsufficientPermissionsException":
+            throw await de_InsufficientPermissionsExceptionRes(parsedOutput, context);
+        case "SnapshotLimitExceededException":
+        case "com.amazonaws.directoryservice#SnapshotLimitExceededException":
+            throw await de_SnapshotLimitExceededExceptionRes(parsedOutput, context);
+        case "CertificateDoesNotExistException":
+        case "com.amazonaws.directoryservice#CertificateDoesNotExistException":
+            throw await de_CertificateDoesNotExistExceptionRes(parsedOutput, context);
+        case "CertificateInUseException":
+        case "com.amazonaws.directoryservice#CertificateInUseException":
+            throw await de_CertificateInUseExceptionRes(parsedOutput, context);
+        case "InvalidNextTokenException":
+        case "com.amazonaws.directoryservice#InvalidNextTokenException":
+            throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+        case "InvalidClientAuthStatusException":
+        case "com.amazonaws.directoryservice#InvalidClientAuthStatusException":
+            throw await de_InvalidClientAuthStatusExceptionRes(parsedOutput, context);
+        case "InvalidLDAPSStatusException":
+        case "com.amazonaws.directoryservice#InvalidLDAPSStatusException":
+            throw await de_InvalidLDAPSStatusExceptionRes(parsedOutput, context);
+        case "NoAvailableCertificateException":
+        case "com.amazonaws.directoryservice#NoAvailableCertificateException":
+            throw await de_NoAvailableCertificateExceptionRes(parsedOutput, context);
+        case "CertificateAlreadyExistsException":
+        case "com.amazonaws.directoryservice#CertificateAlreadyExistsException":
+            throw await de_CertificateAlreadyExistsExceptionRes(parsedOutput, context);
+        case "CertificateLimitExceededException":
+        case "com.amazonaws.directoryservice#CertificateLimitExceededException":
+            throw await de_CertificateLimitExceededExceptionRes(parsedOutput, context);
+        case "InvalidCertificateException":
+        case "com.amazonaws.directoryservice#InvalidCertificateException":
+            throw await de_InvalidCertificateExceptionRes(parsedOutput, context);
+        case "InvalidPasswordException":
+        case "com.amazonaws.directoryservice#InvalidPasswordException":
+            throw await de_InvalidPasswordExceptionRes(parsedOutput, context);
+        case "UserDoesNotExistException":
+        case "com.amazonaws.directoryservice#UserDoesNotExistException":
+            throw await de_UserDoesNotExistExceptionRes(parsedOutput, context);
+        case "InvalidTargetException":
+        case "com.amazonaws.directoryservice#InvalidTargetException":
+            throw await de_InvalidTargetExceptionRes(parsedOutput, context);
+        case "OrganizationsException":
+        case "com.amazonaws.directoryservice#OrganizationsException":
+            throw await de_OrganizationsExceptionRes(parsedOutput, context);
+        case "ShareLimitExceededException":
+        case "com.amazonaws.directoryservice#ShareLimitExceededException":
+            throw await de_ShareLimitExceededExceptionRes(parsedOutput, context);
+        case "DirectoryNotSharedException":
+        case "com.amazonaws.directoryservice#DirectoryNotSharedException":
+            throw await de_DirectoryNotSharedExceptionRes(parsedOutput, context);
+        case "DirectoryInDesiredStateException":
+        case "com.amazonaws.directoryservice#DirectoryInDesiredStateException":
+            throw await de_DirectoryInDesiredStateExceptionRes(parsedOutput, context);
+        case "DomainControllerLimitExceededException":
+        case "com.amazonaws.directoryservice#DomainControllerLimitExceededException":
+            throw await de_DomainControllerLimitExceededExceptionRes(parsedOutput, context);
+        case "IncompatibleSettingsException":
+        case "com.amazonaws.directoryservice#IncompatibleSettingsException":
+            throw await de_IncompatibleSettingsExceptionRes(parsedOutput, context);
+        case "UnsupportedSettingsException":
+        case "com.amazonaws.directoryservice#UnsupportedSettingsException":
+            throw await de_UnsupportedSettingsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({