import { AddTagsToResourceCommandInput, AddTagsToResourceCommandOutput } from "../commands/AddTagsToResourceCommand";
import { CancelCommandCommandInput, CancelCommandCommandOutput } from "../commands/CancelCommandCommand";
import {
  CancelMaintenanceWindowExecutionCommandInput,
  CancelMaintenanceWindowExecutionCommandOutput,
} from "../commands/CancelMaintenanceWindowExecutionCommand";
import { CreateActivationCommandInput, CreateActivationCommandOutput } from "../commands/CreateActivationCommand";
import {
  CreateAssociationBatchCommandInput,
  CreateAssociationBatchCommandOutput,
} from "../commands/CreateAssociationBatchCommand";
import { CreateAssociationCommandInput, CreateAssociationCommandOutput } from "../commands/CreateAssociationCommand";
import { CreateDocumentCommandInput, CreateDocumentCommandOutput } from "../commands/CreateDocumentCommand";
import {
  CreateMaintenanceWindowCommandInput,
  CreateMaintenanceWindowCommandOutput,
} from "../commands/CreateMaintenanceWindowCommand";
import { CreateOpsItemCommandInput, CreateOpsItemCommandOutput } from "../commands/CreateOpsItemCommand";
import {
  CreatePatchBaselineCommandInput,
  CreatePatchBaselineCommandOutput,
} from "../commands/CreatePatchBaselineCommand";
import {
  CreateResourceDataSyncCommandInput,
  CreateResourceDataSyncCommandOutput,
} from "../commands/CreateResourceDataSyncCommand";
import { DeleteActivationCommandInput, DeleteActivationCommandOutput } from "../commands/DeleteActivationCommand";
import { DeleteAssociationCommandInput, DeleteAssociationCommandOutput } from "../commands/DeleteAssociationCommand";
import { DeleteDocumentCommandInput, DeleteDocumentCommandOutput } from "../commands/DeleteDocumentCommand";
import { DeleteInventoryCommandInput, DeleteInventoryCommandOutput } from "../commands/DeleteInventoryCommand";
import {
  DeleteMaintenanceWindowCommandInput,
  DeleteMaintenanceWindowCommandOutput,
} from "../commands/DeleteMaintenanceWindowCommand";
import { DeleteParameterCommandInput, DeleteParameterCommandOutput } from "../commands/DeleteParameterCommand";
import { DeleteParametersCommandInput, DeleteParametersCommandOutput } from "../commands/DeleteParametersCommand";
import {
  DeletePatchBaselineCommandInput,
  DeletePatchBaselineCommandOutput,
} from "../commands/DeletePatchBaselineCommand";
import {
  DeleteResourceDataSyncCommandInput,
  DeleteResourceDataSyncCommandOutput,
} from "../commands/DeleteResourceDataSyncCommand";
import {
  DeregisterManagedInstanceCommandInput,
  DeregisterManagedInstanceCommandOutput,
} from "../commands/DeregisterManagedInstanceCommand";
import {
  DeregisterPatchBaselineForPatchGroupCommandInput,
  DeregisterPatchBaselineForPatchGroupCommandOutput,
} from "../commands/DeregisterPatchBaselineForPatchGroupCommand";
import {
  DeregisterTargetFromMaintenanceWindowCommandInput,
  DeregisterTargetFromMaintenanceWindowCommandOutput,
} from "../commands/DeregisterTargetFromMaintenanceWindowCommand";
import {
  DeregisterTaskFromMaintenanceWindowCommandInput,
  DeregisterTaskFromMaintenanceWindowCommandOutput,
} from "../commands/DeregisterTaskFromMaintenanceWindowCommand";
import {
  DescribeActivationsCommandInput,
  DescribeActivationsCommandOutput,
} from "../commands/DescribeActivationsCommand";
import {
  DescribeAssociationCommandInput,
  DescribeAssociationCommandOutput,
} from "../commands/DescribeAssociationCommand";
import {
  DescribeAssociationExecutionTargetsCommandInput,
  DescribeAssociationExecutionTargetsCommandOutput,
} from "../commands/DescribeAssociationExecutionTargetsCommand";
import {
  DescribeAssociationExecutionsCommandInput,
  DescribeAssociationExecutionsCommandOutput,
} from "../commands/DescribeAssociationExecutionsCommand";
import {
  DescribeAutomationExecutionsCommandInput,
  DescribeAutomationExecutionsCommandOutput,
} from "../commands/DescribeAutomationExecutionsCommand";
import {
  DescribeAutomationStepExecutionsCommandInput,
  DescribeAutomationStepExecutionsCommandOutput,
} from "../commands/DescribeAutomationStepExecutionsCommand";
import {
  DescribeAvailablePatchesCommandInput,
  DescribeAvailablePatchesCommandOutput,
} from "../commands/DescribeAvailablePatchesCommand";
import { DescribeDocumentCommandInput, DescribeDocumentCommandOutput } from "../commands/DescribeDocumentCommand";
import {
  DescribeDocumentPermissionCommandInput,
  DescribeDocumentPermissionCommandOutput,
} from "../commands/DescribeDocumentPermissionCommand";
import {
  DescribeEffectiveInstanceAssociationsCommandInput,
  DescribeEffectiveInstanceAssociationsCommandOutput,
} from "../commands/DescribeEffectiveInstanceAssociationsCommand";
import {
  DescribeEffectivePatchesForPatchBaselineCommandInput,
  DescribeEffectivePatchesForPatchBaselineCommandOutput,
} from "../commands/DescribeEffectivePatchesForPatchBaselineCommand";
import {
  DescribeInstanceAssociationsStatusCommandInput,
  DescribeInstanceAssociationsStatusCommandOutput,
} from "../commands/DescribeInstanceAssociationsStatusCommand";
import {
  DescribeInstanceInformationCommandInput,
  DescribeInstanceInformationCommandOutput,
} from "../commands/DescribeInstanceInformationCommand";
import {
  DescribeInstancePatchStatesCommandInput,
  DescribeInstancePatchStatesCommandOutput,
} from "../commands/DescribeInstancePatchStatesCommand";
import {
  DescribeInstancePatchStatesForPatchGroupCommandInput,
  DescribeInstancePatchStatesForPatchGroupCommandOutput,
} from "../commands/DescribeInstancePatchStatesForPatchGroupCommand";
import {
  DescribeInstancePatchesCommandInput,
  DescribeInstancePatchesCommandOutput,
} from "../commands/DescribeInstancePatchesCommand";
import {
  DescribeInventoryDeletionsCommandInput,
  DescribeInventoryDeletionsCommandOutput,
} from "../commands/DescribeInventoryDeletionsCommand";
import {
  DescribeMaintenanceWindowExecutionTaskInvocationsCommandInput,
  DescribeMaintenanceWindowExecutionTaskInvocationsCommandOutput,
} from "../commands/DescribeMaintenanceWindowExecutionTaskInvocationsCommand";
import {
  DescribeMaintenanceWindowExecutionTasksCommandInput,
  DescribeMaintenanceWindowExecutionTasksCommandOutput,
} from "../commands/DescribeMaintenanceWindowExecutionTasksCommand";
import {
  DescribeMaintenanceWindowExecutionsCommandInput,
  DescribeMaintenanceWindowExecutionsCommandOutput,
} from "../commands/DescribeMaintenanceWindowExecutionsCommand";
import {
  DescribeMaintenanceWindowScheduleCommandInput,
  DescribeMaintenanceWindowScheduleCommandOutput,
} from "../commands/DescribeMaintenanceWindowScheduleCommand";
import {
  DescribeMaintenanceWindowTargetsCommandInput,
  DescribeMaintenanceWindowTargetsCommandOutput,
} from "../commands/DescribeMaintenanceWindowTargetsCommand";
import {
  DescribeMaintenanceWindowTasksCommandInput,
  DescribeMaintenanceWindowTasksCommandOutput,
} from "../commands/DescribeMaintenanceWindowTasksCommand";
import {
  DescribeMaintenanceWindowsCommandInput,
  DescribeMaintenanceWindowsCommandOutput,
} from "../commands/DescribeMaintenanceWindowsCommand";
import {
  DescribeMaintenanceWindowsForTargetCommandInput,
  DescribeMaintenanceWindowsForTargetCommandOutput,
} from "../commands/DescribeMaintenanceWindowsForTargetCommand";
import { DescribeOpsItemsCommandInput, DescribeOpsItemsCommandOutput } from "../commands/DescribeOpsItemsCommand";
import { DescribeParametersCommandInput, DescribeParametersCommandOutput } from "../commands/DescribeParametersCommand";
import {
  DescribePatchBaselinesCommandInput,
  DescribePatchBaselinesCommandOutput,
} from "../commands/DescribePatchBaselinesCommand";
import {
  DescribePatchGroupStateCommandInput,
  DescribePatchGroupStateCommandOutput,
} from "../commands/DescribePatchGroupStateCommand";
import {
  DescribePatchGroupsCommandInput,
  DescribePatchGroupsCommandOutput,
} from "../commands/DescribePatchGroupsCommand";
import {
  DescribePatchPropertiesCommandInput,
  DescribePatchPropertiesCommandOutput,
} from "../commands/DescribePatchPropertiesCommand";
import { DescribeSessionsCommandInput, DescribeSessionsCommandOutput } from "../commands/DescribeSessionsCommand";
import {
  GetAutomationExecutionCommandInput,
  GetAutomationExecutionCommandOutput,
} from "../commands/GetAutomationExecutionCommand";
import { GetCalendarStateCommandInput, GetCalendarStateCommandOutput } from "../commands/GetCalendarStateCommand";
import {
  GetCommandInvocationCommandInput,
  GetCommandInvocationCommandOutput,
} from "../commands/GetCommandInvocationCommand";
import {
  GetConnectionStatusCommandInput,
  GetConnectionStatusCommandOutput,
} from "../commands/GetConnectionStatusCommand";
import {
  GetDefaultPatchBaselineCommandInput,
  GetDefaultPatchBaselineCommandOutput,
} from "../commands/GetDefaultPatchBaselineCommand";
import {
  GetDeployablePatchSnapshotForInstanceCommandInput,
  GetDeployablePatchSnapshotForInstanceCommandOutput,
} from "../commands/GetDeployablePatchSnapshotForInstanceCommand";
import { GetDocumentCommandInput, GetDocumentCommandOutput } from "../commands/GetDocumentCommand";
import { GetInventoryCommandInput, GetInventoryCommandOutput } from "../commands/GetInventoryCommand";
import { GetInventorySchemaCommandInput, GetInventorySchemaCommandOutput } from "../commands/GetInventorySchemaCommand";
import {
  GetMaintenanceWindowCommandInput,
  GetMaintenanceWindowCommandOutput,
} from "../commands/GetMaintenanceWindowCommand";
import {
  GetMaintenanceWindowExecutionCommandInput,
  GetMaintenanceWindowExecutionCommandOutput,
} from "../commands/GetMaintenanceWindowExecutionCommand";
import {
  GetMaintenanceWindowExecutionTaskCommandInput,
  GetMaintenanceWindowExecutionTaskCommandOutput,
} from "../commands/GetMaintenanceWindowExecutionTaskCommand";
import {
  GetMaintenanceWindowExecutionTaskInvocationCommandInput,
  GetMaintenanceWindowExecutionTaskInvocationCommandOutput,
} from "../commands/GetMaintenanceWindowExecutionTaskInvocationCommand";
import {
  GetMaintenanceWindowTaskCommandInput,
  GetMaintenanceWindowTaskCommandOutput,
} from "../commands/GetMaintenanceWindowTaskCommand";
import { GetOpsItemCommandInput, GetOpsItemCommandOutput } from "../commands/GetOpsItemCommand";
import { GetOpsSummaryCommandInput, GetOpsSummaryCommandOutput } from "../commands/GetOpsSummaryCommand";
import { GetParameterCommandInput, GetParameterCommandOutput } from "../commands/GetParameterCommand";
import {
  GetParameterHistoryCommandInput,
  GetParameterHistoryCommandOutput,
} from "../commands/GetParameterHistoryCommand";
import {
  GetParametersByPathCommandInput,
  GetParametersByPathCommandOutput,
} from "../commands/GetParametersByPathCommand";
import { GetParametersCommandInput, GetParametersCommandOutput } from "../commands/GetParametersCommand";
import { GetPatchBaselineCommandInput, GetPatchBaselineCommandOutput } from "../commands/GetPatchBaselineCommand";
import {
  GetPatchBaselineForPatchGroupCommandInput,
  GetPatchBaselineForPatchGroupCommandOutput,
} from "../commands/GetPatchBaselineForPatchGroupCommand";
import { GetServiceSettingCommandInput, GetServiceSettingCommandOutput } from "../commands/GetServiceSettingCommand";
import {
  LabelParameterVersionCommandInput,
  LabelParameterVersionCommandOutput,
} from "../commands/LabelParameterVersionCommand";
import {
  ListAssociationVersionsCommandInput,
  ListAssociationVersionsCommandOutput,
} from "../commands/ListAssociationVersionsCommand";
import { ListAssociationsCommandInput, ListAssociationsCommandOutput } from "../commands/ListAssociationsCommand";
import {
  ListCommandInvocationsCommandInput,
  ListCommandInvocationsCommandOutput,
} from "../commands/ListCommandInvocationsCommand";
import { ListCommandsCommandInput, ListCommandsCommandOutput } from "../commands/ListCommandsCommand";
import {
  ListComplianceItemsCommandInput,
  ListComplianceItemsCommandOutput,
} from "../commands/ListComplianceItemsCommand";
import {
  ListComplianceSummariesCommandInput,
  ListComplianceSummariesCommandOutput,
} from "../commands/ListComplianceSummariesCommand";
import {
  ListDocumentVersionsCommandInput,
  ListDocumentVersionsCommandOutput,
} from "../commands/ListDocumentVersionsCommand";
import { ListDocumentsCommandInput, ListDocumentsCommandOutput } from "../commands/ListDocumentsCommand";
import {
  ListInventoryEntriesCommandInput,
  ListInventoryEntriesCommandOutput,
} from "../commands/ListInventoryEntriesCommand";
import {
  ListResourceComplianceSummariesCommandInput,
  ListResourceComplianceSummariesCommandOutput,
} from "../commands/ListResourceComplianceSummariesCommand";
import {
  ListResourceDataSyncCommandInput,
  ListResourceDataSyncCommandOutput,
} from "../commands/ListResourceDataSyncCommand";
import {
  ListTagsForResourceCommandInput,
  ListTagsForResourceCommandOutput,
} from "../commands/ListTagsForResourceCommand";
import {
  ModifyDocumentPermissionCommandInput,
  ModifyDocumentPermissionCommandOutput,
} from "../commands/ModifyDocumentPermissionCommand";
import { PutComplianceItemsCommandInput, PutComplianceItemsCommandOutput } from "../commands/PutComplianceItemsCommand";
import { PutInventoryCommandInput, PutInventoryCommandOutput } from "../commands/PutInventoryCommand";
import { PutParameterCommandInput, PutParameterCommandOutput } from "../commands/PutParameterCommand";
import {
  RegisterDefaultPatchBaselineCommandInput,
  RegisterDefaultPatchBaselineCommandOutput,
} from "../commands/RegisterDefaultPatchBaselineCommand";
import {
  RegisterPatchBaselineForPatchGroupCommandInput,
  RegisterPatchBaselineForPatchGroupCommandOutput,
} from "../commands/RegisterPatchBaselineForPatchGroupCommand";
import {
  RegisterTargetWithMaintenanceWindowCommandInput,
  RegisterTargetWithMaintenanceWindowCommandOutput,
} from "../commands/RegisterTargetWithMaintenanceWindowCommand";
import {
  RegisterTaskWithMaintenanceWindowCommandInput,
  RegisterTaskWithMaintenanceWindowCommandOutput,
} from "../commands/RegisterTaskWithMaintenanceWindowCommand";
import {
  RemoveTagsFromResourceCommandInput,
  RemoveTagsFromResourceCommandOutput,
} from "../commands/RemoveTagsFromResourceCommand";
import {
  ResetServiceSettingCommandInput,
  ResetServiceSettingCommandOutput,
} from "../commands/ResetServiceSettingCommand";
import { ResumeSessionCommandInput, ResumeSessionCommandOutput } from "../commands/ResumeSessionCommand";
import {
  SendAutomationSignalCommandInput,
  SendAutomationSignalCommandOutput,
} from "../commands/SendAutomationSignalCommand";
import { SendCommandCommandInput, SendCommandCommandOutput } from "../commands/SendCommandCommand";
import {
  StartAssociationsOnceCommandInput,
  StartAssociationsOnceCommandOutput,
} from "../commands/StartAssociationsOnceCommand";
import {
  StartAutomationExecutionCommandInput,
  StartAutomationExecutionCommandOutput,
} from "../commands/StartAutomationExecutionCommand";
import { StartSessionCommandInput, StartSessionCommandOutput } from "../commands/StartSessionCommand";
import {
  StopAutomationExecutionCommandInput,
  StopAutomationExecutionCommandOutput,
} from "../commands/StopAutomationExecutionCommand";
import { TerminateSessionCommandInput, TerminateSessionCommandOutput } from "../commands/TerminateSessionCommand";
import { UpdateAssociationCommandInput, UpdateAssociationCommandOutput } from "../commands/UpdateAssociationCommand";
import {
  UpdateAssociationStatusCommandInput,
  UpdateAssociationStatusCommandOutput,
} from "../commands/UpdateAssociationStatusCommand";
import { UpdateDocumentCommandInput, UpdateDocumentCommandOutput } from "../commands/UpdateDocumentCommand";
import {
  UpdateDocumentDefaultVersionCommandInput,
  UpdateDocumentDefaultVersionCommandOutput,
} from "../commands/UpdateDocumentDefaultVersionCommand";
import {
  UpdateMaintenanceWindowCommandInput,
  UpdateMaintenanceWindowCommandOutput,
} from "../commands/UpdateMaintenanceWindowCommand";
import {
  UpdateMaintenanceWindowTargetCommandInput,
  UpdateMaintenanceWindowTargetCommandOutput,
} from "../commands/UpdateMaintenanceWindowTargetCommand";
import {
  UpdateMaintenanceWindowTaskCommandInput,
  UpdateMaintenanceWindowTaskCommandOutput,
} from "../commands/UpdateMaintenanceWindowTaskCommand";
import {
  UpdateManagedInstanceRoleCommandInput,
  UpdateManagedInstanceRoleCommandOutput,
} from "../commands/UpdateManagedInstanceRoleCommand";
import { UpdateOpsItemCommandInput, UpdateOpsItemCommandOutput } from "../commands/UpdateOpsItemCommand";
import {
  UpdatePatchBaselineCommandInput,
  UpdatePatchBaselineCommandOutput,
} from "../commands/UpdatePatchBaselineCommand";
import {
  UpdateResourceDataSyncCommandInput,
  UpdateResourceDataSyncCommandOutput,
} from "../commands/UpdateResourceDataSyncCommand";
import {
  UpdateServiceSettingCommandInput,
  UpdateServiceSettingCommandOutput,
} from "../commands/UpdateServiceSettingCommand";
import {
  AccountSharingInfo,
  Activation,
  AddTagsToResourceRequest,
  AddTagsToResourceResult,
  AlreadyExistsException,
  AssociatedInstances,
  AssociationAlreadyExists,
  AssociationDescription,
  AssociationDoesNotExist,
  AssociationExecution,
  AssociationExecutionDoesNotExist,
  AssociationExecutionFilter,
  AssociationExecutionTarget,
  AssociationExecutionTargetsFilter,
  AssociationLimitExceeded,
  AssociationOverview,
  AssociationStatus,
  AttachmentInformation,
  AttachmentsSource,
  AutomationExecutionFilter,
  AutomationExecutionMetadata,
  AutomationExecutionNotFoundException,
  CancelCommandRequest,
  CancelCommandResult,
  CancelMaintenanceWindowExecutionRequest,
  CancelMaintenanceWindowExecutionResult,
  CreateActivationRequest,
  CreateActivationResult,
  CreateAssociationBatchRequest,
  CreateAssociationBatchRequestEntry,
  CreateAssociationBatchResult,
  CreateAssociationRequest,
  CreateAssociationResult,
  CreateDocumentRequest,
  CreateDocumentResult,
  CreateMaintenanceWindowRequest,
  CreateMaintenanceWindowResult,
  CreateOpsItemRequest,
  CreateOpsItemResponse,
  CreatePatchBaselineRequest,
  CreatePatchBaselineResult,
  CreateResourceDataSyncRequest,
  CreateResourceDataSyncResult,
  DeleteActivationRequest,
  DeleteActivationResult,
  DeleteAssociationRequest,
  DeleteAssociationResult,
  DeleteDocumentRequest,
  DeleteDocumentResult,
  DeleteInventoryRequest,
  DeleteInventoryResult,
  DeleteMaintenanceWindowRequest,
  DeleteMaintenanceWindowResult,
  DeleteParameterRequest,
  DeleteParameterResult,
  DeleteParametersRequest,
  DeleteParametersResult,
  DeletePatchBaselineRequest,
  DeletePatchBaselineResult,
  DeleteResourceDataSyncRequest,
  DeleteResourceDataSyncResult,
  DeregisterManagedInstanceRequest,
  DeregisterManagedInstanceResult,
  DeregisterPatchBaselineForPatchGroupRequest,
  DeregisterPatchBaselineForPatchGroupResult,
  DeregisterTargetFromMaintenanceWindowRequest,
  DeregisterTargetFromMaintenanceWindowResult,
  DeregisterTaskFromMaintenanceWindowRequest,
  DeregisterTaskFromMaintenanceWindowResult,
  DescribeActivationsFilter,
  DescribeActivationsRequest,
  DescribeActivationsResult,
  DescribeAssociationExecutionTargetsRequest,
  DescribeAssociationExecutionTargetsResult,
  DescribeAssociationExecutionsRequest,
  DescribeAssociationExecutionsResult,
  DescribeAssociationRequest,
  DescribeAssociationResult,
  DescribeAutomationExecutionsRequest,
  DescribeAutomationExecutionsResult,
  DescribeAutomationStepExecutionsRequest,
  DescribeAutomationStepExecutionsResult,
  DescribeAvailablePatchesRequest,
  DescribeAvailablePatchesResult,
  DescribeDocumentPermissionRequest,
  DescribeDocumentPermissionResponse,
  DescribeDocumentRequest,
  DescribeDocumentResult,
  DescribeEffectiveInstanceAssociationsRequest,
  DescribeEffectiveInstanceAssociationsResult,
  DescribeEffectivePatchesForPatchBaselineRequest,
  DescribeEffectivePatchesForPatchBaselineResult,
  DescribeInstanceAssociationsStatusRequest,
  DescribeInstanceAssociationsStatusResult,
  DescribeInstanceInformationRequest,
  DescribeInstanceInformationResult,
  DescribeInstancePatchStatesForPatchGroupRequest,
  DescribeInstancePatchStatesForPatchGroupResult,
  DescribeInstancePatchStatesRequest,
  DescribeInstancePatchStatesResult,
  DescribeInstancePatchesRequest,
  DescribeInstancePatchesResult,
  DescribeInventoryDeletionsRequest,
  DescribeInventoryDeletionsResult,
  DescribeMaintenanceWindowExecutionTaskInvocationsRequest,
  DescribeMaintenanceWindowExecutionTaskInvocationsResult,
  DescribeMaintenanceWindowExecutionTasksRequest,
  DescribeMaintenanceWindowExecutionTasksResult,
  DescribeMaintenanceWindowExecutionsRequest,
  DescribeMaintenanceWindowExecutionsResult,
  DescribeMaintenanceWindowScheduleRequest,
  DescribeMaintenanceWindowScheduleResult,
  DescribeMaintenanceWindowTargetsRequest,
  DescribeMaintenanceWindowTargetsResult,
  DescribeMaintenanceWindowTasksRequest,
  DescribeMaintenanceWindowTasksResult,
  DescribeMaintenanceWindowsForTargetRequest,
  DescribeMaintenanceWindowsForTargetResult,
  DescribeMaintenanceWindowsRequest,
  DescribeMaintenanceWindowsResult,
  DescribeOpsItemsRequest,
  DescribeOpsItemsResponse,
  DescribeParametersRequest,
  DescribeParametersResult,
  DescribePatchBaselinesRequest,
  DescribePatchBaselinesResult,
  DescribePatchGroupStateRequest,
  DescribePatchGroupStateResult,
  DescribePatchGroupsRequest,
  DescribePatchGroupsResult,
  DescribePatchPropertiesRequest,
  DescribePatchPropertiesResult,
  DescribeSessionsRequest,
  DocumentAlreadyExists,
  DocumentDescription,
  DocumentLimitExceeded,
  DocumentParameter,
  DocumentRequires,
  DoesNotExistException,
  DuplicateInstanceId,
  EffectivePatch,
  FailedCreateAssociation,
  FailureDetails,
  IdempotentParameterMismatch,
  InstanceAggregatedAssociationOverview,
  InstanceAssociation,
  InstanceAssociationOutputLocation,
  InstanceAssociationOutputUrl,
  InstanceAssociationStatusInfo,
  InstanceInformation,
  InstanceInformationFilter,
  InstanceInformationStringFilter,
  InstancePatchState,
  InstancePatchStateFilter,
  InternalServerError,
  InvalidActivation,
  InvalidActivationId,
  InvalidAssociationVersion,
  InvalidCommandId,
  InvalidDeleteInventoryParametersException,
  InvalidDeletionIdException,
  InvalidDocument,
  InvalidDocumentContent,
  InvalidDocumentOperation,
  InvalidDocumentSchemaVersion,
  InvalidDocumentVersion,
  InvalidFilter,
  InvalidFilterKey,
  InvalidFilterOption,
  InvalidFilterValue,
  InvalidInstanceId,
  InvalidInstanceInformationFilterValue,
  InvalidInventoryRequestException,
  InvalidNextToken,
  InvalidOptionException,
  InvalidOutputLocation,
  InvalidParameters,
  InvalidPermissionType,
  InvalidResourceId,
  InvalidResourceType,
  InvalidSchedule,
  InvalidTarget,
  InvalidTypeNameException,
  InventoryDeletionStatusItem,
  InventoryDeletionSummary,
  InventoryDeletionSummaryItem,
  LoggingInfo,
  MaintenanceWindowExecution,
  MaintenanceWindowExecutionTaskIdentity,
  MaintenanceWindowExecutionTaskInvocationIdentity,
  MaintenanceWindowFilter,
  MaintenanceWindowIdentity,
  MaintenanceWindowIdentityForTarget,
  MaintenanceWindowTarget,
  MaintenanceWindowTask,
  MaintenanceWindowTaskParameterValueExpression,
  MaxDocumentSizeExceeded,
  OpsItemAlreadyExistsException,
  OpsItemDataValue,
  OpsItemFilter,
  OpsItemInvalidParameterException,
  OpsItemLimitExceededException,
  OpsItemNotification,
  OpsItemSummary,
  OutputSource,
  ParameterInlinePolicy,
  ParameterMetadata,
  ParameterNotFound,
  ParameterStringFilter,
  ParametersFilter,
  Patch,
  PatchBaselineIdentity,
  PatchComplianceData,
  PatchFilter,
  PatchFilterGroup,
  PatchGroupPatchBaselineMapping,
  PatchOrchestratorFilter,
  PatchRule,
  PatchRuleGroup,
  PatchSource,
  PatchStatus,
  PlatformType,
  RelatedOpsItem,
  ResolvedTargets,
  ResourceDataSyncAlreadyExistsException,
  ResourceDataSyncAwsOrganizationsSource,
  ResourceDataSyncCountExceededException,
  ResourceDataSyncDestinationDataSharing,
  ResourceDataSyncInvalidConfigurationException,
  ResourceDataSyncNotFoundException,
  ResourceDataSyncOrganizationalUnit,
  ResourceDataSyncS3Destination,
  ResourceDataSyncSource,
  ResourceInUseException,
  ResourceLimitExceededException,
  S3OutputLocation,
  S3OutputUrl,
  ScheduledWindowExecution,
  SessionFilter,
  SessionManagerOutputUrl,
  StepExecution,
  StepExecutionFilter,
  Tag,
  Target,
  TargetInUseException,
  TargetLocation,
  TooManyTagsError,
  TooManyUpdates,
  UnsupportedOperatingSystem,
  UnsupportedPlatformType,
} from "../models/models_0";
import {
  Association,
  AssociationFilter,
  AssociationVersionInfo,
  AssociationVersionLimitExceeded,
  AttachmentContent,
  AutomationDefinitionNotFoundException,
  AutomationDefinitionVersionNotFoundException,
  AutomationExecution,
  AutomationExecutionLimitExceededException,
  AutomationStepNotFoundException,
  CloudWatchOutputConfig,
  Command,
  CommandFilter,
  CommandInvocation,
  CommandPlugin,
  ComplianceExecutionSummary,
  ComplianceItem,
  ComplianceItemEntry,
  ComplianceStringFilter,
  ComplianceSummaryItem,
  ComplianceTypeCountLimitExceededException,
  CompliantSummary,
  CustomSchemaCountLimitExceededException,
  DescribeSessionsResponse,
  DocumentDefaultVersionDescription,
  DocumentFilter,
  DocumentIdentifier,
  DocumentKeyValuesFilter,
  DocumentPermissionLimit,
  DocumentVersionInfo,
  DocumentVersionLimitExceeded,
  DuplicateDocumentContent,
  DuplicateDocumentVersionName,
  FeatureNotAvailableException,
  GetAutomationExecutionRequest,
  GetAutomationExecutionResult,
  GetCalendarStateRequest,
  GetCalendarStateResponse,
  GetCommandInvocationRequest,
  GetCommandInvocationResult,
  GetConnectionStatusRequest,
  GetConnectionStatusResponse,
  GetDefaultPatchBaselineRequest,
  GetDefaultPatchBaselineResult,
  GetDeployablePatchSnapshotForInstanceRequest,
  GetDeployablePatchSnapshotForInstanceResult,
  GetDocumentRequest,
  GetDocumentResult,
  GetInventoryRequest,
  GetInventoryResult,
  GetInventorySchemaRequest,
  GetInventorySchemaResult,
  GetMaintenanceWindowExecutionRequest,
  GetMaintenanceWindowExecutionResult,
  GetMaintenanceWindowExecutionTaskInvocationRequest,
  GetMaintenanceWindowExecutionTaskInvocationResult,
  GetMaintenanceWindowExecutionTaskRequest,
  GetMaintenanceWindowExecutionTaskResult,
  GetMaintenanceWindowRequest,
  GetMaintenanceWindowResult,
  GetMaintenanceWindowTaskRequest,
  GetMaintenanceWindowTaskResult,
  GetOpsItemRequest,
  GetOpsItemResponse,
  GetOpsSummaryRequest,
  GetOpsSummaryResult,
  GetParameterHistoryRequest,
  GetParameterHistoryResult,
  GetParameterRequest,
  GetParameterResult,
  GetParametersByPathRequest,
  GetParametersByPathResult,
  GetParametersRequest,
  GetParametersResult,
  GetPatchBaselineForPatchGroupRequest,
  GetPatchBaselineForPatchGroupResult,
  GetPatchBaselineRequest,
  GetPatchBaselineResult,
  GetServiceSettingRequest,
  GetServiceSettingResult,
  HierarchyLevelLimitExceededException,
  HierarchyTypeMismatchException,
  IncompatiblePolicyException,
  InvalidAggregatorException,
  InvalidAllowedPatternException,
  InvalidAssociation,
  InvalidAutomationExecutionParametersException,
  InvalidAutomationSignalException,
  InvalidAutomationStatusUpdateException,
  InvalidDocumentType,
  InvalidInventoryGroupException,
  InvalidInventoryItemContextException,
  InvalidItemContentException,
  InvalidKeyId,
  InvalidNotificationConfig,
  InvalidOutputFolder,
  InvalidPluginName,
  InvalidPolicyAttributeException,
  InvalidPolicyTypeException,
  InvalidResultAttributeException,
  InvalidRole,
  InvalidUpdate,
  InventoryAggregator,
  InventoryFilter,
  InventoryGroup,
  InventoryItem,
  InventoryItemAttribute,
  InventoryItemSchema,
  InventoryResultEntity,
  InventoryResultItem,
  InvocationDoesNotExist,
  ItemContentMismatchException,
  ItemSizeLimitExceededException,
  LabelParameterVersionRequest,
  LabelParameterVersionResult,
  ListAssociationVersionsRequest,
  ListAssociationVersionsResult,
  ListAssociationsRequest,
  ListAssociationsResult,
  ListCommandInvocationsRequest,
  ListCommandInvocationsResult,
  ListCommandsRequest,
  ListCommandsResult,
  ListComplianceItemsRequest,
  ListComplianceItemsResult,
  ListComplianceSummariesRequest,
  ListComplianceSummariesResult,
  ListDocumentVersionsRequest,
  ListDocumentVersionsResult,
  ListDocumentsRequest,
  ListDocumentsResult,
  ListInventoryEntriesRequest,
  ListInventoryEntriesResult,
  ListResourceComplianceSummariesRequest,
  ListResourceComplianceSummariesResult,
  ListResourceDataSyncRequest,
  ListResourceDataSyncResult,
  ListTagsForResourceRequest,
  ListTagsForResourceResult,
  MaintenanceWindowAutomationParameters,
  MaintenanceWindowLambdaParameters,
  MaintenanceWindowRunCommandParameters,
  MaintenanceWindowStepFunctionsParameters,
  MaintenanceWindowTaskInvocationParameters,
  ModifyDocumentPermissionRequest,
  ModifyDocumentPermissionResponse,
  NonCompliantSummary,
  NotificationConfig,
  NotificationEvent,
  OpsAggregator,
  OpsEntity,
  OpsEntityItem,
  OpsFilter,
  OpsItem,
  OpsItemNotFoundException,
  OpsResultAttribute,
  Parameter,
  ParameterAlreadyExists,
  ParameterHistory,
  ParameterLimitExceeded,
  ParameterMaxVersionLimitExceeded,
  ParameterPatternMismatchException,
  ParameterVersionLabelLimitExceeded,
  ParameterVersionNotFound,
  PoliciesLimitExceededException,
  ProgressCounters,
  PutComplianceItemsRequest,
  PutComplianceItemsResult,
  PutInventoryRequest,
  PutInventoryResult,
  PutParameterRequest,
  PutParameterResult,
  RegisterDefaultPatchBaselineRequest,
  RegisterDefaultPatchBaselineResult,
  RegisterPatchBaselineForPatchGroupRequest,
  RegisterPatchBaselineForPatchGroupResult,
  RegisterTargetWithMaintenanceWindowRequest,
  RegisterTargetWithMaintenanceWindowResult,
  RegisterTaskWithMaintenanceWindowRequest,
  RegisterTaskWithMaintenanceWindowResult,
  RemoveTagsFromResourceRequest,
  RemoveTagsFromResourceResult,
  ResetServiceSettingRequest,
  ResetServiceSettingResult,
  ResourceComplianceSummaryItem,
  ResourceDataSyncConflictException,
  ResourceDataSyncItem,
  ResourceDataSyncSourceWithState,
  ResultAttribute,
  ResumeSessionRequest,
  ResumeSessionResponse,
  SendAutomationSignalRequest,
  SendAutomationSignalResult,
  SendCommandRequest,
  SendCommandResult,
  ServiceSetting,
  ServiceSettingNotFound,
  Session,
  SeveritySummary,
  StartAssociationsOnceRequest,
  StartAssociationsOnceResult,
  StartAutomationExecutionRequest,
  StartAutomationExecutionResult,
  StartSessionRequest,
  StartSessionResponse,
  StatusUnchanged,
  StopAutomationExecutionRequest,
  StopAutomationExecutionResult,
  SubTypeCountLimitExceededException,
  TargetNotConnected,
  TerminateSessionRequest,
  TerminateSessionResponse,
  TotalSizeLimitExceededException,
  UnsupportedCalendarException,
  UnsupportedFeatureRequiredException,
  UnsupportedInventoryItemContextException,
  UnsupportedInventorySchemaVersionException,
  UnsupportedParameterType,
  UpdateAssociationRequest,
  UpdateAssociationResult,
  UpdateAssociationStatusRequest,
  UpdateAssociationStatusResult,
  UpdateDocumentDefaultVersionRequest,
  UpdateDocumentDefaultVersionResult,
  UpdateDocumentRequest,
  UpdateDocumentResult,
  UpdateMaintenanceWindowRequest,
  UpdateMaintenanceWindowResult,
  UpdateMaintenanceWindowTargetRequest,
  UpdateMaintenanceWindowTargetResult,
  UpdateMaintenanceWindowTaskRequest,
  UpdateMaintenanceWindowTaskResult,
  UpdateManagedInstanceRoleRequest,
  UpdateManagedInstanceRoleResult,
  UpdateOpsItemRequest,
  UpdateOpsItemResponse,
  UpdatePatchBaselineRequest,
  UpdatePatchBaselineResult,
  UpdateResourceDataSyncRequest,
  UpdateResourceDataSyncResult,
  UpdateServiceSettingRequest,
  UpdateServiceSettingResult,
} from "../models/models_1";
import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
import { SmithyException as __SmithyException } from "@aws-sdk/smithy-client";
import {
  Endpoint as __Endpoint,
  HeaderBag as __HeaderBag,
  MetadataBearer as __MetadataBearer,
  ResponseMetadata as __ResponseMetadata,
  SerdeContext as __SerdeContext,
} from "@aws-sdk/types";
import { v4 as generateIdempotencyToken } from "uuid";

export const serializeAws_json1_1AddTagsToResourceCommand = async (
  input: AddTagsToResourceCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.AddTagsToResource",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1AddTagsToResourceRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CancelCommandCommand = async (
  input: CancelCommandCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CancelCommand",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CancelCommandRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CancelMaintenanceWindowExecutionCommand = async (
  input: CancelMaintenanceWindowExecutionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CancelMaintenanceWindowExecution",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CancelMaintenanceWindowExecutionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateActivationCommand = async (
  input: CreateActivationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateActivation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateActivationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateAssociationCommand = async (
  input: CreateAssociationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateAssociation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateAssociationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateAssociationBatchCommand = async (
  input: CreateAssociationBatchCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateAssociationBatch",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateAssociationBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateDocumentCommand = async (
  input: CreateDocumentCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateDocument",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateDocumentRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateMaintenanceWindowCommand = async (
  input: CreateMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateOpsItemCommand = async (
  input: CreateOpsItemCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateOpsItem",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateOpsItemRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreatePatchBaselineCommand = async (
  input: CreatePatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreatePatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreatePatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1CreateResourceDataSyncCommand = async (
  input: CreateResourceDataSyncCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.CreateResourceDataSync",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1CreateResourceDataSyncRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteActivationCommand = async (
  input: DeleteActivationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteActivation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteActivationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteAssociationCommand = async (
  input: DeleteAssociationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteAssociation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteAssociationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteDocumentCommand = async (
  input: DeleteDocumentCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteDocument",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteDocumentRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteInventoryCommand = async (
  input: DeleteInventoryCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteInventory",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteInventoryRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteMaintenanceWindowCommand = async (
  input: DeleteMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteParameterCommand = async (
  input: DeleteParameterCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteParameter",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteParameterRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteParametersCommand = async (
  input: DeleteParametersCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteParameters",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteParametersRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeletePatchBaselineCommand = async (
  input: DeletePatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeletePatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeletePatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeleteResourceDataSyncCommand = async (
  input: DeleteResourceDataSyncCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeleteResourceDataSync",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeleteResourceDataSyncRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeregisterManagedInstanceCommand = async (
  input: DeregisterManagedInstanceCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeregisterManagedInstance",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeregisterManagedInstanceRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeregisterPatchBaselineForPatchGroupCommand = async (
  input: DeregisterPatchBaselineForPatchGroupCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeregisterPatchBaselineForPatchGroup",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeregisterPatchBaselineForPatchGroupRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeregisterTargetFromMaintenanceWindowCommand = async (
  input: DeregisterTargetFromMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeregisterTargetFromMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeregisterTargetFromMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DeregisterTaskFromMaintenanceWindowCommand = async (
  input: DeregisterTaskFromMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DeregisterTaskFromMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DeregisterTaskFromMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeActivationsCommand = async (
  input: DescribeActivationsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeActivations",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeActivationsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeAssociationCommand = async (
  input: DescribeAssociationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeAssociation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeAssociationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeAssociationExecutionsCommand = async (
  input: DescribeAssociationExecutionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeAssociationExecutions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeAssociationExecutionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeAssociationExecutionTargetsCommand = async (
  input: DescribeAssociationExecutionTargetsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeAssociationExecutionTargets",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeAssociationExecutionTargetsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeAutomationExecutionsCommand = async (
  input: DescribeAutomationExecutionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeAutomationExecutions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeAutomationExecutionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeAutomationStepExecutionsCommand = async (
  input: DescribeAutomationStepExecutionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeAutomationStepExecutions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeAutomationStepExecutionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeAvailablePatchesCommand = async (
  input: DescribeAvailablePatchesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeAvailablePatches",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeAvailablePatchesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeDocumentCommand = async (
  input: DescribeDocumentCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeDocument",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeDocumentRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeDocumentPermissionCommand = async (
  input: DescribeDocumentPermissionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeDocumentPermission",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeDocumentPermissionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeEffectiveInstanceAssociationsCommand = async (
  input: DescribeEffectiveInstanceAssociationsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeEffectiveInstanceAssociations",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeEffectiveInstanceAssociationsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeEffectivePatchesForPatchBaselineCommand = async (
  input: DescribeEffectivePatchesForPatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeEffectivePatchesForPatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeEffectivePatchesForPatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeInstanceAssociationsStatusCommand = async (
  input: DescribeInstanceAssociationsStatusCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeInstanceAssociationsStatus",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeInstanceAssociationsStatusRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeInstanceInformationCommand = async (
  input: DescribeInstanceInformationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeInstanceInformation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeInstanceInformationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeInstancePatchesCommand = async (
  input: DescribeInstancePatchesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeInstancePatches",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeInstancePatchesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeInstancePatchStatesCommand = async (
  input: DescribeInstancePatchStatesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeInstancePatchStates",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeInstancePatchStatesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeInstancePatchStatesForPatchGroupCommand = async (
  input: DescribeInstancePatchStatesForPatchGroupCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeInstancePatchStatesForPatchGroup",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeInstancePatchStatesForPatchGroupRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeInventoryDeletionsCommand = async (
  input: DescribeInventoryDeletionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeInventoryDeletions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeInventoryDeletionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowExecutionsCommand = async (
  input: DescribeMaintenanceWindowExecutionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowExecutions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowExecutionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsCommand = async (
  input: DescribeMaintenanceWindowExecutionTaskInvocationsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowExecutionTasksCommand = async (
  input: DescribeMaintenanceWindowExecutionTasksCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowExecutionTasks",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowExecutionTasksRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowsCommand = async (
  input: DescribeMaintenanceWindowsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindows",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowScheduleCommand = async (
  input: DescribeMaintenanceWindowScheduleCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowSchedule",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowScheduleRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowsForTargetCommand = async (
  input: DescribeMaintenanceWindowsForTargetCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowsForTarget",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowsForTargetRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowTargetsCommand = async (
  input: DescribeMaintenanceWindowTargetsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowTargets",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowTargetsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeMaintenanceWindowTasksCommand = async (
  input: DescribeMaintenanceWindowTasksCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeMaintenanceWindowTasks",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeMaintenanceWindowTasksRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeOpsItemsCommand = async (
  input: DescribeOpsItemsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeOpsItems",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeOpsItemsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeParametersCommand = async (
  input: DescribeParametersCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeParameters",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeParametersRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribePatchBaselinesCommand = async (
  input: DescribePatchBaselinesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribePatchBaselines",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribePatchBaselinesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribePatchGroupsCommand = async (
  input: DescribePatchGroupsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribePatchGroups",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribePatchGroupsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribePatchGroupStateCommand = async (
  input: DescribePatchGroupStateCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribePatchGroupState",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribePatchGroupStateRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribePatchPropertiesCommand = async (
  input: DescribePatchPropertiesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribePatchProperties",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribePatchPropertiesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1DescribeSessionsCommand = async (
  input: DescribeSessionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.DescribeSessions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1DescribeSessionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetAutomationExecutionCommand = async (
  input: GetAutomationExecutionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetAutomationExecution",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetAutomationExecutionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetCalendarStateCommand = async (
  input: GetCalendarStateCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetCalendarState",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetCalendarStateRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetCommandInvocationCommand = async (
  input: GetCommandInvocationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetCommandInvocation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetCommandInvocationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetConnectionStatusCommand = async (
  input: GetConnectionStatusCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetConnectionStatus",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetConnectionStatusRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetDefaultPatchBaselineCommand = async (
  input: GetDefaultPatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetDefaultPatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetDefaultPatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetDeployablePatchSnapshotForInstanceCommand = async (
  input: GetDeployablePatchSnapshotForInstanceCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetDeployablePatchSnapshotForInstance",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetDeployablePatchSnapshotForInstanceRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetDocumentCommand = async (
  input: GetDocumentCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetDocument",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetDocumentRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetInventoryCommand = async (
  input: GetInventoryCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetInventory",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetInventoryRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetInventorySchemaCommand = async (
  input: GetInventorySchemaCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetInventorySchema",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetInventorySchemaRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetMaintenanceWindowCommand = async (
  input: GetMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetMaintenanceWindowExecutionCommand = async (
  input: GetMaintenanceWindowExecutionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetMaintenanceWindowExecution",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetMaintenanceWindowExecutionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetMaintenanceWindowExecutionTaskCommand = async (
  input: GetMaintenanceWindowExecutionTaskCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetMaintenanceWindowExecutionTask",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetMaintenanceWindowExecutionTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationCommand = async (
  input: GetMaintenanceWindowExecutionTaskInvocationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetMaintenanceWindowExecutionTaskInvocation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetMaintenanceWindowTaskCommand = async (
  input: GetMaintenanceWindowTaskCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetMaintenanceWindowTask",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetMaintenanceWindowTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetOpsItemCommand = async (
  input: GetOpsItemCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetOpsItem",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetOpsItemRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetOpsSummaryCommand = async (
  input: GetOpsSummaryCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetOpsSummary",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetOpsSummaryRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetParameterCommand = async (
  input: GetParameterCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetParameter",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetParameterRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetParameterHistoryCommand = async (
  input: GetParameterHistoryCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetParameterHistory",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetParameterHistoryRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetParametersCommand = async (
  input: GetParametersCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetParameters",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetParametersRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetParametersByPathCommand = async (
  input: GetParametersByPathCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetParametersByPath",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetParametersByPathRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetPatchBaselineCommand = async (
  input: GetPatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetPatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetPatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetPatchBaselineForPatchGroupCommand = async (
  input: GetPatchBaselineForPatchGroupCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetPatchBaselineForPatchGroup",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetPatchBaselineForPatchGroupRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1GetServiceSettingCommand = async (
  input: GetServiceSettingCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.GetServiceSetting",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1GetServiceSettingRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1LabelParameterVersionCommand = async (
  input: LabelParameterVersionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.LabelParameterVersion",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1LabelParameterVersionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListAssociationsCommand = async (
  input: ListAssociationsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListAssociations",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListAssociationsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListAssociationVersionsCommand = async (
  input: ListAssociationVersionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListAssociationVersions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListAssociationVersionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListCommandInvocationsCommand = async (
  input: ListCommandInvocationsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListCommandInvocations",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListCommandInvocationsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListCommandsCommand = async (
  input: ListCommandsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListCommands",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListCommandsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListComplianceItemsCommand = async (
  input: ListComplianceItemsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListComplianceItems",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListComplianceItemsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListComplianceSummariesCommand = async (
  input: ListComplianceSummariesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListComplianceSummaries",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListComplianceSummariesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListDocumentsCommand = async (
  input: ListDocumentsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListDocuments",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListDocumentsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListDocumentVersionsCommand = async (
  input: ListDocumentVersionsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListDocumentVersions",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListDocumentVersionsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListInventoryEntriesCommand = async (
  input: ListInventoryEntriesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListInventoryEntries",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListInventoryEntriesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListResourceComplianceSummariesCommand = async (
  input: ListResourceComplianceSummariesCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListResourceComplianceSummaries",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListResourceComplianceSummariesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListResourceDataSyncCommand = async (
  input: ListResourceDataSyncCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListResourceDataSync",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListResourceDataSyncRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ListTagsForResourceCommand = async (
  input: ListTagsForResourceCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ListTagsForResource",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ModifyDocumentPermissionCommand = async (
  input: ModifyDocumentPermissionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ModifyDocumentPermission",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ModifyDocumentPermissionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1PutComplianceItemsCommand = async (
  input: PutComplianceItemsCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.PutComplianceItems",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1PutComplianceItemsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1PutInventoryCommand = async (
  input: PutInventoryCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.PutInventory",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1PutInventoryRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1PutParameterCommand = async (
  input: PutParameterCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.PutParameter",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1PutParameterRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1RegisterDefaultPatchBaselineCommand = async (
  input: RegisterDefaultPatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.RegisterDefaultPatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1RegisterDefaultPatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1RegisterPatchBaselineForPatchGroupCommand = async (
  input: RegisterPatchBaselineForPatchGroupCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.RegisterPatchBaselineForPatchGroup",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1RegisterPatchBaselineForPatchGroupRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1RegisterTargetWithMaintenanceWindowCommand = async (
  input: RegisterTargetWithMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.RegisterTargetWithMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1RegisterTargetWithMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1RegisterTaskWithMaintenanceWindowCommand = async (
  input: RegisterTaskWithMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.RegisterTaskWithMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1RegisterTaskWithMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1RemoveTagsFromResourceCommand = async (
  input: RemoveTagsFromResourceCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.RemoveTagsFromResource",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1RemoveTagsFromResourceRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ResetServiceSettingCommand = async (
  input: ResetServiceSettingCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ResetServiceSetting",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ResetServiceSettingRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1ResumeSessionCommand = async (
  input: ResumeSessionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.ResumeSession",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1ResumeSessionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1SendAutomationSignalCommand = async (
  input: SendAutomationSignalCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.SendAutomationSignal",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1SendAutomationSignalRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1SendCommandCommand = async (
  input: SendCommandCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.SendCommand",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1SendCommandRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1StartAssociationsOnceCommand = async (
  input: StartAssociationsOnceCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.StartAssociationsOnce",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1StartAssociationsOnceRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1StartAutomationExecutionCommand = async (
  input: StartAutomationExecutionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.StartAutomationExecution",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1StartAutomationExecutionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1StartSessionCommand = async (
  input: StartSessionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.StartSession",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1StartSessionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1StopAutomationExecutionCommand = async (
  input: StopAutomationExecutionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.StopAutomationExecution",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1StopAutomationExecutionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1TerminateSessionCommand = async (
  input: TerminateSessionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.TerminateSession",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1TerminateSessionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateAssociationCommand = async (
  input: UpdateAssociationCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateAssociation",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateAssociationRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateAssociationStatusCommand = async (
  input: UpdateAssociationStatusCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateAssociationStatus",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateAssociationStatusRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateDocumentCommand = async (
  input: UpdateDocumentCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateDocument",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateDocumentRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateDocumentDefaultVersionCommand = async (
  input: UpdateDocumentDefaultVersionCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateDocumentDefaultVersion",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateDocumentDefaultVersionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateMaintenanceWindowCommand = async (
  input: UpdateMaintenanceWindowCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateMaintenanceWindow",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateMaintenanceWindowRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateMaintenanceWindowTargetCommand = async (
  input: UpdateMaintenanceWindowTargetCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateMaintenanceWindowTarget",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateMaintenanceWindowTargetRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateMaintenanceWindowTaskCommand = async (
  input: UpdateMaintenanceWindowTaskCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateMaintenanceWindowTask",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateMaintenanceWindowTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateManagedInstanceRoleCommand = async (
  input: UpdateManagedInstanceRoleCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateManagedInstanceRole",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateManagedInstanceRoleRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateOpsItemCommand = async (
  input: UpdateOpsItemCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateOpsItem",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateOpsItemRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdatePatchBaselineCommand = async (
  input: UpdatePatchBaselineCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdatePatchBaseline",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdatePatchBaselineRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateResourceDataSyncCommand = async (
  input: UpdateResourceDataSyncCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateResourceDataSync",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateResourceDataSyncRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const serializeAws_json1_1UpdateServiceSettingCommand = async (
  input: UpdateServiceSettingCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "Content-Type": "application/x-amz-json-1.1",
    "X-Amz-Target": "AmazonSSM.UpdateServiceSetting",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1UpdateServiceSettingRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
};

export const deserializeAws_json1_1AddTagsToResourceCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<AddTagsToResourceCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1AddTagsToResourceCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1AddTagsToResourceResult(data, context);
  const response: AddTagsToResourceCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1AddTagsToResourceCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<AddTagsToResourceCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceType":
    case "com.amazonaws.ssm#InvalidResourceType":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyTagsError":
    case "com.amazonaws.ssm#TooManyTagsError":
      response = {
        ...(await deserializeAws_json1_1TooManyTagsErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CancelCommandCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CancelCommandCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CancelCommandCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CancelCommandResult(data, context);
  const response: CancelCommandCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CancelCommandCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CancelCommandCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DuplicateInstanceId":
    case "com.amazonaws.ssm#DuplicateInstanceId":
      response = {
        ...(await deserializeAws_json1_1DuplicateInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidCommandId":
    case "com.amazonaws.ssm#InvalidCommandId":
      response = {
        ...(await deserializeAws_json1_1InvalidCommandIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CancelMaintenanceWindowExecutionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CancelMaintenanceWindowExecutionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CancelMaintenanceWindowExecutionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CancelMaintenanceWindowExecutionResult(data, context);
  const response: CancelMaintenanceWindowExecutionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CancelMaintenanceWindowExecutionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CancelMaintenanceWindowExecutionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateActivationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateActivationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateActivationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateActivationResult(data, context);
  const response: CreateActivationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateActivationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateActivationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateAssociationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateAssociationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateAssociationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateAssociationResult(data, context);
  const response: CreateAssociationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateAssociationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateAssociationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationAlreadyExists":
    case "com.amazonaws.ssm#AssociationAlreadyExists":
      response = {
        ...(await deserializeAws_json1_1AssociationAlreadyExistsResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "AssociationLimitExceeded":
    case "com.amazonaws.ssm#AssociationLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1AssociationLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidOutputLocation":
    case "com.amazonaws.ssm#InvalidOutputLocation":
      response = {
        ...(await deserializeAws_json1_1InvalidOutputLocationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidParameters":
    case "com.amazonaws.ssm#InvalidParameters":
      response = {
        ...(await deserializeAws_json1_1InvalidParametersResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidSchedule":
    case "com.amazonaws.ssm#InvalidSchedule":
      response = {
        ...(await deserializeAws_json1_1InvalidScheduleResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTarget":
    case "com.amazonaws.ssm#InvalidTarget":
      response = {
        ...(await deserializeAws_json1_1InvalidTargetResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedPlatformType":
    case "com.amazonaws.ssm#UnsupportedPlatformType":
      response = {
        ...(await deserializeAws_json1_1UnsupportedPlatformTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateAssociationBatchCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateAssociationBatchCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateAssociationBatchCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateAssociationBatchResult(data, context);
  const response: CreateAssociationBatchCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateAssociationBatchCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateAssociationBatchCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationLimitExceeded":
    case "com.amazonaws.ssm#AssociationLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1AssociationLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "DuplicateInstanceId":
    case "com.amazonaws.ssm#DuplicateInstanceId":
      response = {
        ...(await deserializeAws_json1_1DuplicateInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidOutputLocation":
    case "com.amazonaws.ssm#InvalidOutputLocation":
      response = {
        ...(await deserializeAws_json1_1InvalidOutputLocationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidParameters":
    case "com.amazonaws.ssm#InvalidParameters":
      response = {
        ...(await deserializeAws_json1_1InvalidParametersResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidSchedule":
    case "com.amazonaws.ssm#InvalidSchedule":
      response = {
        ...(await deserializeAws_json1_1InvalidScheduleResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTarget":
    case "com.amazonaws.ssm#InvalidTarget":
      response = {
        ...(await deserializeAws_json1_1InvalidTargetResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedPlatformType":
    case "com.amazonaws.ssm#UnsupportedPlatformType":
      response = {
        ...(await deserializeAws_json1_1UnsupportedPlatformTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateDocumentCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateDocumentCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateDocumentCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateDocumentResult(data, context);
  const response: CreateDocumentCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateDocumentCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateDocumentCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DocumentAlreadyExists":
    case "com.amazonaws.ssm#DocumentAlreadyExists":
      response = {
        ...(await deserializeAws_json1_1DocumentAlreadyExistsResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "DocumentLimitExceeded":
    case "com.amazonaws.ssm#DocumentLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1DocumentLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentContent":
    case "com.amazonaws.ssm#InvalidDocumentContent":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentContentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentSchemaVersion":
    case "com.amazonaws.ssm#InvalidDocumentSchemaVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentSchemaVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "MaxDocumentSizeExceeded":
    case "com.amazonaws.ssm#MaxDocumentSizeExceeded":
      response = {
        ...(await deserializeAws_json1_1MaxDocumentSizeExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateMaintenanceWindowResult(data, context);
  const response: CreateMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "IdempotentParameterMismatch":
    case "com.amazonaws.ssm#IdempotentParameterMismatch":
      response = {
        ...(await deserializeAws_json1_1IdempotentParameterMismatchResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceLimitExceededException":
    case "com.amazonaws.ssm#ResourceLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateOpsItemCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateOpsItemCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateOpsItemCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateOpsItemResponse(data, context);
  const response: CreateOpsItemCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateOpsItemCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateOpsItemCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemAlreadyExistsException":
    case "com.amazonaws.ssm#OpsItemAlreadyExistsException":
      response = {
        ...(await deserializeAws_json1_1OpsItemAlreadyExistsExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemInvalidParameterException":
    case "com.amazonaws.ssm#OpsItemInvalidParameterException":
      response = {
        ...(await deserializeAws_json1_1OpsItemInvalidParameterExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemLimitExceededException":
    case "com.amazonaws.ssm#OpsItemLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1OpsItemLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreatePatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreatePatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreatePatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreatePatchBaselineResult(data, context);
  const response: CreatePatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreatePatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreatePatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "IdempotentParameterMismatch":
    case "com.amazonaws.ssm#IdempotentParameterMismatch":
      response = {
        ...(await deserializeAws_json1_1IdempotentParameterMismatchResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceLimitExceededException":
    case "com.amazonaws.ssm#ResourceLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1CreateResourceDataSyncCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateResourceDataSyncCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1CreateResourceDataSyncCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1CreateResourceDataSyncResult(data, context);
  const response: CreateResourceDataSyncCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1CreateResourceDataSyncCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<CreateResourceDataSyncCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncAlreadyExistsException":
    case "com.amazonaws.ssm#ResourceDataSyncAlreadyExistsException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncAlreadyExistsExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncCountExceededException":
    case "com.amazonaws.ssm#ResourceDataSyncCountExceededException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncCountExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncInvalidConfigurationException":
    case "com.amazonaws.ssm#ResourceDataSyncInvalidConfigurationException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncInvalidConfigurationExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteActivationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteActivationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteActivationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteActivationResult(data, context);
  const response: DeleteActivationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteActivationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteActivationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidActivation":
    case "com.amazonaws.ssm#InvalidActivation":
      response = {
        ...(await deserializeAws_json1_1InvalidActivationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidActivationId":
    case "com.amazonaws.ssm#InvalidActivationId":
      response = {
        ...(await deserializeAws_json1_1InvalidActivationIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteAssociationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteAssociationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteAssociationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteAssociationResult(data, context);
  const response: DeleteAssociationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteAssociationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteAssociationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteDocumentCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteDocumentCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteDocumentCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteDocumentResult(data, context);
  const response: DeleteDocumentCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteDocumentCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteDocumentCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociatedInstances":
    case "com.amazonaws.ssm#AssociatedInstances":
      response = {
        ...(await deserializeAws_json1_1AssociatedInstancesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentOperation":
    case "com.amazonaws.ssm#InvalidDocumentOperation":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentOperationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteInventoryCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteInventoryCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteInventoryCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteInventoryResult(data, context);
  const response: DeleteInventoryCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteInventoryCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteInventoryCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDeleteInventoryParametersException":
    case "com.amazonaws.ssm#InvalidDeleteInventoryParametersException":
      response = {
        ...(await deserializeAws_json1_1InvalidDeleteInventoryParametersExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInventoryRequestException":
    case "com.amazonaws.ssm#InvalidInventoryRequestException":
      response = {
        ...(await deserializeAws_json1_1InvalidInventoryRequestExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidOptionException":
    case "com.amazonaws.ssm#InvalidOptionException":
      response = {
        ...(await deserializeAws_json1_1InvalidOptionExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTypeNameException":
    case "com.amazonaws.ssm#InvalidTypeNameException":
      response = {
        ...(await deserializeAws_json1_1InvalidTypeNameExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteMaintenanceWindowResult(data, context);
  const response: DeleteMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteParameterCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteParameterCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteParameterCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteParameterResult(data, context);
  const response: DeleteParameterCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteParameterCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteParameterCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterNotFound":
    case "com.amazonaws.ssm#ParameterNotFound":
      response = {
        ...(await deserializeAws_json1_1ParameterNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteParametersCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteParametersCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteParametersCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteParametersResult(data, context);
  const response: DeleteParametersCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteParametersCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteParametersCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeletePatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeletePatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeletePatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeletePatchBaselineResult(data, context);
  const response: DeletePatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeletePatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeletePatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceInUseException":
    case "com.amazonaws.ssm#ResourceInUseException":
      response = {
        ...(await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeleteResourceDataSyncCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteResourceDataSyncCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeleteResourceDataSyncCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeleteResourceDataSyncResult(data, context);
  const response: DeleteResourceDataSyncCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeleteResourceDataSyncCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeleteResourceDataSyncCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncInvalidConfigurationException":
    case "com.amazonaws.ssm#ResourceDataSyncInvalidConfigurationException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncInvalidConfigurationExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncNotFoundException":
    case "com.amazonaws.ssm#ResourceDataSyncNotFoundException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeregisterManagedInstanceCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterManagedInstanceCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeregisterManagedInstanceCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeregisterManagedInstanceResult(data, context);
  const response: DeregisterManagedInstanceCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeregisterManagedInstanceCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterManagedInstanceCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeregisterPatchBaselineForPatchGroupCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterPatchBaselineForPatchGroupCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeregisterPatchBaselineForPatchGroupCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeregisterPatchBaselineForPatchGroupResult(data, context);
  const response: DeregisterPatchBaselineForPatchGroupCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeregisterPatchBaselineForPatchGroupCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterPatchBaselineForPatchGroupCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeregisterTargetFromMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterTargetFromMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeregisterTargetFromMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeregisterTargetFromMaintenanceWindowResult(data, context);
  const response: DeregisterTargetFromMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeregisterTargetFromMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterTargetFromMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TargetInUseException":
    case "com.amazonaws.ssm#TargetInUseException":
      response = {
        ...(await deserializeAws_json1_1TargetInUseExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DeregisterTaskFromMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterTaskFromMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DeregisterTaskFromMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DeregisterTaskFromMaintenanceWindowResult(data, context);
  const response: DeregisterTaskFromMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DeregisterTaskFromMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DeregisterTaskFromMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeActivationsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeActivationsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeActivationsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeActivationsResult(data, context);
  const response: DescribeActivationsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeActivationsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeActivationsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeAssociationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAssociationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeAssociationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeAssociationResult(data, context);
  const response: DescribeAssociationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeAssociationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAssociationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAssociationVersion":
    case "com.amazonaws.ssm#InvalidAssociationVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidAssociationVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeAssociationExecutionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAssociationExecutionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeAssociationExecutionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeAssociationExecutionsResult(data, context);
  const response: DescribeAssociationExecutionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeAssociationExecutionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAssociationExecutionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeAssociationExecutionTargetsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAssociationExecutionTargetsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeAssociationExecutionTargetsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeAssociationExecutionTargetsResult(data, context);
  const response: DescribeAssociationExecutionTargetsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeAssociationExecutionTargetsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAssociationExecutionTargetsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "AssociationExecutionDoesNotExist":
    case "com.amazonaws.ssm#AssociationExecutionDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationExecutionDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeAutomationExecutionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAutomationExecutionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeAutomationExecutionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeAutomationExecutionsResult(data, context);
  const response: DescribeAutomationExecutionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeAutomationExecutionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAutomationExecutionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterValue":
    case "com.amazonaws.ssm#InvalidFilterValue":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterValueResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeAutomationStepExecutionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAutomationStepExecutionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeAutomationStepExecutionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeAutomationStepExecutionsResult(data, context);
  const response: DescribeAutomationStepExecutionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeAutomationStepExecutionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAutomationStepExecutionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AutomationExecutionNotFoundException":
    case "com.amazonaws.ssm#AutomationExecutionNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationExecutionNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterValue":
    case "com.amazonaws.ssm#InvalidFilterValue":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterValueResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeAvailablePatchesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAvailablePatchesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeAvailablePatchesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeAvailablePatchesResult(data, context);
  const response: DescribeAvailablePatchesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeAvailablePatchesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeAvailablePatchesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeDocumentCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeDocumentCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeDocumentCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeDocumentResult(data, context);
  const response: DescribeDocumentCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeDocumentCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeDocumentCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeDocumentPermissionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeDocumentPermissionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeDocumentPermissionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeDocumentPermissionResponse(data, context);
  const response: DescribeDocumentPermissionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeDocumentPermissionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeDocumentPermissionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidPermissionType":
    case "com.amazonaws.ssm#InvalidPermissionType":
      response = {
        ...(await deserializeAws_json1_1InvalidPermissionTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeEffectiveInstanceAssociationsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeEffectiveInstanceAssociationsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeEffectiveInstanceAssociationsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeEffectiveInstanceAssociationsResult(data, context);
  const response: DescribeEffectiveInstanceAssociationsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeEffectiveInstanceAssociationsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeEffectiveInstanceAssociationsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeEffectivePatchesForPatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeEffectivePatchesForPatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeEffectivePatchesForPatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeEffectivePatchesForPatchBaselineResult(data, context);
  const response: DescribeEffectivePatchesForPatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeEffectivePatchesForPatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeEffectivePatchesForPatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedOperatingSystem":
    case "com.amazonaws.ssm#UnsupportedOperatingSystem":
      response = {
        ...(await deserializeAws_json1_1UnsupportedOperatingSystemResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeInstanceAssociationsStatusCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstanceAssociationsStatusCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeInstanceAssociationsStatusCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeInstanceAssociationsStatusResult(data, context);
  const response: DescribeInstanceAssociationsStatusCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeInstanceAssociationsStatusCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstanceAssociationsStatusCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeInstanceInformationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstanceInformationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeInstanceInformationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeInstanceInformationResult(data, context);
  const response: DescribeInstanceInformationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeInstanceInformationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstanceInformationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceInformationFilterValue":
    case "com.amazonaws.ssm#InvalidInstanceInformationFilterValue":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceInformationFilterValueResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeInstancePatchesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstancePatchesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeInstancePatchesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeInstancePatchesResult(data, context);
  const response: DescribeInstancePatchesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeInstancePatchesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstancePatchesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeInstancePatchStatesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstancePatchStatesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeInstancePatchStatesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeInstancePatchStatesResult(data, context);
  const response: DescribeInstancePatchStatesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeInstancePatchStatesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstancePatchStatesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeInstancePatchStatesForPatchGroupCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstancePatchStatesForPatchGroupCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeInstancePatchStatesForPatchGroupCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeInstancePatchStatesForPatchGroupResult(data, context);
  const response: DescribeInstancePatchStatesForPatchGroupCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeInstancePatchStatesForPatchGroupCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInstancePatchStatesForPatchGroupCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeInventoryDeletionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInventoryDeletionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeInventoryDeletionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeInventoryDeletionsResult(data, context);
  const response: DescribeInventoryDeletionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeInventoryDeletionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeInventoryDeletionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDeletionIdException":
    case "com.amazonaws.ssm#InvalidDeletionIdException":
      response = {
        ...(await deserializeAws_json1_1InvalidDeletionIdExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowExecutionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowExecutionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowExecutionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowExecutionsResult(data, context);
  const response: DescribeMaintenanceWindowExecutionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowExecutionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowExecutionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowExecutionTaskInvocationsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsResult(data, context);
  const response: DescribeMaintenanceWindowExecutionTaskInvocationsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowExecutionTaskInvocationsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowExecutionTasksCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowExecutionTasksCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowExecutionTasksCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowExecutionTasksResult(data, context);
  const response: DescribeMaintenanceWindowExecutionTasksCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowExecutionTasksCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowExecutionTasksCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowsResult(data, context);
  const response: DescribeMaintenanceWindowsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowScheduleCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowScheduleCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowScheduleCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowScheduleResult(data, context);
  const response: DescribeMaintenanceWindowScheduleCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowScheduleCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowScheduleCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowsForTargetCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowsForTargetCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowsForTargetCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowsForTargetResult(data, context);
  const response: DescribeMaintenanceWindowsForTargetCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowsForTargetCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowsForTargetCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowTargetsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowTargetsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowTargetsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowTargetsResult(data, context);
  const response: DescribeMaintenanceWindowTargetsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowTargetsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowTargetsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeMaintenanceWindowTasksCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowTasksCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeMaintenanceWindowTasksCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeMaintenanceWindowTasksResult(data, context);
  const response: DescribeMaintenanceWindowTasksCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeMaintenanceWindowTasksCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeMaintenanceWindowTasksCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeOpsItemsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeOpsItemsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeOpsItemsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeOpsItemsResponse(data, context);
  const response: DescribeOpsItemsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeOpsItemsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeOpsItemsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeParametersCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeParametersCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeParametersCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeParametersResult(data, context);
  const response: DescribeParametersCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeParametersCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeParametersCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterOption":
    case "com.amazonaws.ssm#InvalidFilterOption":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterOptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterValue":
    case "com.amazonaws.ssm#InvalidFilterValue":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterValueResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribePatchBaselinesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchBaselinesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribePatchBaselinesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribePatchBaselinesResult(data, context);
  const response: DescribePatchBaselinesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribePatchBaselinesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchBaselinesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribePatchGroupsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchGroupsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribePatchGroupsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribePatchGroupsResult(data, context);
  const response: DescribePatchGroupsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribePatchGroupsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchGroupsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribePatchGroupStateCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchGroupStateCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribePatchGroupStateCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribePatchGroupStateResult(data, context);
  const response: DescribePatchGroupStateCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribePatchGroupStateCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchGroupStateCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribePatchPropertiesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchPropertiesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribePatchPropertiesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribePatchPropertiesResult(data, context);
  const response: DescribePatchPropertiesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribePatchPropertiesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribePatchPropertiesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1DescribeSessionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeSessionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1DescribeSessionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1DescribeSessionsResponse(data, context);
  const response: DescribeSessionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1DescribeSessionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<DescribeSessionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetAutomationExecutionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetAutomationExecutionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetAutomationExecutionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetAutomationExecutionResult(data, context);
  const response: GetAutomationExecutionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetAutomationExecutionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetAutomationExecutionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AutomationExecutionNotFoundException":
    case "com.amazonaws.ssm#AutomationExecutionNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationExecutionNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetCalendarStateCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetCalendarStateCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetCalendarStateCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetCalendarStateResponse(data, context);
  const response: GetCalendarStateCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetCalendarStateCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetCalendarStateCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentType":
    case "com.amazonaws.ssm#InvalidDocumentType":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedCalendarException":
    case "com.amazonaws.ssm#UnsupportedCalendarException":
      response = {
        ...(await deserializeAws_json1_1UnsupportedCalendarExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetCommandInvocationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetCommandInvocationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetCommandInvocationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetCommandInvocationResult(data, context);
  const response: GetCommandInvocationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetCommandInvocationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetCommandInvocationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidCommandId":
    case "com.amazonaws.ssm#InvalidCommandId":
      response = {
        ...(await deserializeAws_json1_1InvalidCommandIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidPluginName":
    case "com.amazonaws.ssm#InvalidPluginName":
      response = {
        ...(await deserializeAws_json1_1InvalidPluginNameResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvocationDoesNotExist":
    case "com.amazonaws.ssm#InvocationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1InvocationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetConnectionStatusCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetConnectionStatusCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetConnectionStatusCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetConnectionStatusResponse(data, context);
  const response: GetConnectionStatusCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetConnectionStatusCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetConnectionStatusCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetDefaultPatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetDefaultPatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetDefaultPatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetDefaultPatchBaselineResult(data, context);
  const response: GetDefaultPatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetDefaultPatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetDefaultPatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetDeployablePatchSnapshotForInstanceCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetDeployablePatchSnapshotForInstanceCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetDeployablePatchSnapshotForInstanceCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetDeployablePatchSnapshotForInstanceResult(data, context);
  const response: GetDeployablePatchSnapshotForInstanceCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetDeployablePatchSnapshotForInstanceCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetDeployablePatchSnapshotForInstanceCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedFeatureRequiredException":
    case "com.amazonaws.ssm#UnsupportedFeatureRequiredException":
      response = {
        ...(await deserializeAws_json1_1UnsupportedFeatureRequiredExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedOperatingSystem":
    case "com.amazonaws.ssm#UnsupportedOperatingSystem":
      response = {
        ...(await deserializeAws_json1_1UnsupportedOperatingSystemResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetDocumentCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetDocumentCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetDocumentCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetDocumentResult(data, context);
  const response: GetDocumentCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetDocumentCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetDocumentCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetInventoryCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetInventoryCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetInventoryCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetInventoryResult(data, context);
  const response: GetInventoryCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetInventoryCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetInventoryCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAggregatorException":
    case "com.amazonaws.ssm#InvalidAggregatorException":
      response = {
        ...(await deserializeAws_json1_1InvalidAggregatorExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInventoryGroupException":
    case "com.amazonaws.ssm#InvalidInventoryGroupException":
      response = {
        ...(await deserializeAws_json1_1InvalidInventoryGroupExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResultAttributeException":
    case "com.amazonaws.ssm#InvalidResultAttributeException":
      response = {
        ...(await deserializeAws_json1_1InvalidResultAttributeExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTypeNameException":
    case "com.amazonaws.ssm#InvalidTypeNameException":
      response = {
        ...(await deserializeAws_json1_1InvalidTypeNameExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetInventorySchemaCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetInventorySchemaCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetInventorySchemaCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetInventorySchemaResult(data, context);
  const response: GetInventorySchemaCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetInventorySchemaCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetInventorySchemaCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTypeNameException":
    case "com.amazonaws.ssm#InvalidTypeNameException":
      response = {
        ...(await deserializeAws_json1_1InvalidTypeNameExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetMaintenanceWindowResult(data, context);
  const response: GetMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetMaintenanceWindowExecutionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowExecutionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetMaintenanceWindowExecutionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetMaintenanceWindowExecutionResult(data, context);
  const response: GetMaintenanceWindowExecutionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetMaintenanceWindowExecutionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowExecutionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetMaintenanceWindowExecutionTaskCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowExecutionTaskCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetMaintenanceWindowExecutionTaskCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetMaintenanceWindowExecutionTaskResult(data, context);
  const response: GetMaintenanceWindowExecutionTaskCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetMaintenanceWindowExecutionTaskCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowExecutionTaskCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowExecutionTaskInvocationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationResult(data, context);
  const response: GetMaintenanceWindowExecutionTaskInvocationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowExecutionTaskInvocationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetMaintenanceWindowTaskCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowTaskCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetMaintenanceWindowTaskCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetMaintenanceWindowTaskResult(data, context);
  const response: GetMaintenanceWindowTaskCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetMaintenanceWindowTaskCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetMaintenanceWindowTaskCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetOpsItemCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetOpsItemCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetOpsItemCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetOpsItemResponse(data, context);
  const response: GetOpsItemCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetOpsItemCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetOpsItemCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemNotFoundException":
    case "com.amazonaws.ssm#OpsItemNotFoundException":
      response = {
        ...(await deserializeAws_json1_1OpsItemNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetOpsSummaryCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetOpsSummaryCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetOpsSummaryCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetOpsSummaryResult(data, context);
  const response: GetOpsSummaryCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetOpsSummaryCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetOpsSummaryCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAggregatorException":
    case "com.amazonaws.ssm#InvalidAggregatorException":
      response = {
        ...(await deserializeAws_json1_1InvalidAggregatorExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTypeNameException":
    case "com.amazonaws.ssm#InvalidTypeNameException":
      response = {
        ...(await deserializeAws_json1_1InvalidTypeNameExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncNotFoundException":
    case "com.amazonaws.ssm#ResourceDataSyncNotFoundException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetParameterCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParameterCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetParameterCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetParameterResult(data, context);
  const response: GetParameterCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetParameterCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParameterCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidKeyId":
    case "com.amazonaws.ssm#InvalidKeyId":
      response = {
        ...(await deserializeAws_json1_1InvalidKeyIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterNotFound":
    case "com.amazonaws.ssm#ParameterNotFound":
      response = {
        ...(await deserializeAws_json1_1ParameterNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterVersionNotFound":
    case "com.amazonaws.ssm#ParameterVersionNotFound":
      response = {
        ...(await deserializeAws_json1_1ParameterVersionNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetParameterHistoryCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParameterHistoryCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetParameterHistoryCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetParameterHistoryResult(data, context);
  const response: GetParameterHistoryCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetParameterHistoryCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParameterHistoryCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidKeyId":
    case "com.amazonaws.ssm#InvalidKeyId":
      response = {
        ...(await deserializeAws_json1_1InvalidKeyIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterNotFound":
    case "com.amazonaws.ssm#ParameterNotFound":
      response = {
        ...(await deserializeAws_json1_1ParameterNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetParametersCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParametersCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetParametersCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetParametersResult(data, context);
  const response: GetParametersCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetParametersCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParametersCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidKeyId":
    case "com.amazonaws.ssm#InvalidKeyId":
      response = {
        ...(await deserializeAws_json1_1InvalidKeyIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetParametersByPathCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParametersByPathCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetParametersByPathCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetParametersByPathResult(data, context);
  const response: GetParametersByPathCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetParametersByPathCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetParametersByPathCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterOption":
    case "com.amazonaws.ssm#InvalidFilterOption":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterOptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterValue":
    case "com.amazonaws.ssm#InvalidFilterValue":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterValueResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidKeyId":
    case "com.amazonaws.ssm#InvalidKeyId":
      response = {
        ...(await deserializeAws_json1_1InvalidKeyIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetPatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetPatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetPatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetPatchBaselineResult(data, context);
  const response: GetPatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetPatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetPatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetPatchBaselineForPatchGroupCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetPatchBaselineForPatchGroupCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetPatchBaselineForPatchGroupCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetPatchBaselineForPatchGroupResult(data, context);
  const response: GetPatchBaselineForPatchGroupCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetPatchBaselineForPatchGroupCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetPatchBaselineForPatchGroupCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1GetServiceSettingCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetServiceSettingCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1GetServiceSettingCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1GetServiceSettingResult(data, context);
  const response: GetServiceSettingCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1GetServiceSettingCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<GetServiceSettingCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ServiceSettingNotFound":
    case "com.amazonaws.ssm#ServiceSettingNotFound":
      response = {
        ...(await deserializeAws_json1_1ServiceSettingNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1LabelParameterVersionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<LabelParameterVersionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1LabelParameterVersionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1LabelParameterVersionResult(data, context);
  const response: LabelParameterVersionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1LabelParameterVersionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<LabelParameterVersionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterNotFound":
    case "com.amazonaws.ssm#ParameterNotFound":
      response = {
        ...(await deserializeAws_json1_1ParameterNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterVersionLabelLimitExceeded":
    case "com.amazonaws.ssm#ParameterVersionLabelLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1ParameterVersionLabelLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterVersionNotFound":
    case "com.amazonaws.ssm#ParameterVersionNotFound":
      response = {
        ...(await deserializeAws_json1_1ParameterVersionNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListAssociationsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListAssociationsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListAssociationsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListAssociationsResult(data, context);
  const response: ListAssociationsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListAssociationsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListAssociationsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListAssociationVersionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListAssociationVersionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListAssociationVersionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListAssociationVersionsResult(data, context);
  const response: ListAssociationVersionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListAssociationVersionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListAssociationVersionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListCommandInvocationsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListCommandInvocationsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListCommandInvocationsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListCommandInvocationsResult(data, context);
  const response: ListCommandInvocationsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListCommandInvocationsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListCommandInvocationsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidCommandId":
    case "com.amazonaws.ssm#InvalidCommandId":
      response = {
        ...(await deserializeAws_json1_1InvalidCommandIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListCommandsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListCommandsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListCommandsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListCommandsResult(data, context);
  const response: ListCommandsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListCommandsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListCommandsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidCommandId":
    case "com.amazonaws.ssm#InvalidCommandId":
      response = {
        ...(await deserializeAws_json1_1InvalidCommandIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListComplianceItemsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListComplianceItemsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListComplianceItemsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListComplianceItemsResult(data, context);
  const response: ListComplianceItemsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListComplianceItemsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListComplianceItemsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceType":
    case "com.amazonaws.ssm#InvalidResourceType":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListComplianceSummariesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListComplianceSummariesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListComplianceSummariesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListComplianceSummariesResult(data, context);
  const response: ListComplianceSummariesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListComplianceSummariesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListComplianceSummariesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListDocumentsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListDocumentsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListDocumentsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListDocumentsResult(data, context);
  const response: ListDocumentsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListDocumentsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListDocumentsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilterKey":
    case "com.amazonaws.ssm#InvalidFilterKey":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterKeyResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListDocumentVersionsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListDocumentVersionsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListDocumentVersionsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListDocumentVersionsResult(data, context);
  const response: ListDocumentVersionsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListDocumentVersionsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListDocumentVersionsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListInventoryEntriesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListInventoryEntriesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListInventoryEntriesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListInventoryEntriesResult(data, context);
  const response: ListInventoryEntriesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListInventoryEntriesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListInventoryEntriesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTypeNameException":
    case "com.amazonaws.ssm#InvalidTypeNameException":
      response = {
        ...(await deserializeAws_json1_1InvalidTypeNameExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListResourceComplianceSummariesCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListResourceComplianceSummariesCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListResourceComplianceSummariesCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListResourceComplianceSummariesResult(data, context);
  const response: ListResourceComplianceSummariesCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListResourceComplianceSummariesCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListResourceComplianceSummariesCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidFilter":
    case "com.amazonaws.ssm#InvalidFilter":
      response = {
        ...(await deserializeAws_json1_1InvalidFilterResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListResourceDataSyncCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListResourceDataSyncCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListResourceDataSyncCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListResourceDataSyncResult(data, context);
  const response: ListResourceDataSyncCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListResourceDataSyncCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListResourceDataSyncCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNextToken":
    case "com.amazonaws.ssm#InvalidNextToken":
      response = {
        ...(await deserializeAws_json1_1InvalidNextTokenResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncInvalidConfigurationException":
    case "com.amazonaws.ssm#ResourceDataSyncInvalidConfigurationException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncInvalidConfigurationExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ListTagsForResourceCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListTagsForResourceCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ListTagsForResourceResult(data, context);
  const response: ListTagsForResourceCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ListTagsForResourceCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ListTagsForResourceCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceType":
    case "com.amazonaws.ssm#InvalidResourceType":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ModifyDocumentPermissionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ModifyDocumentPermissionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ModifyDocumentPermissionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ModifyDocumentPermissionResponse(data, context);
  const response: ModifyDocumentPermissionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ModifyDocumentPermissionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ModifyDocumentPermissionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DocumentLimitExceeded":
    case "com.amazonaws.ssm#DocumentLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1DocumentLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "DocumentPermissionLimit":
    case "com.amazonaws.ssm#DocumentPermissionLimit":
      response = {
        ...(await deserializeAws_json1_1DocumentPermissionLimitResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidPermissionType":
    case "com.amazonaws.ssm#InvalidPermissionType":
      response = {
        ...(await deserializeAws_json1_1InvalidPermissionTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1PutComplianceItemsCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<PutComplianceItemsCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1PutComplianceItemsCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1PutComplianceItemsResult(data, context);
  const response: PutComplianceItemsCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1PutComplianceItemsCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<PutComplianceItemsCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "ComplianceTypeCountLimitExceededException":
    case "com.amazonaws.ssm#ComplianceTypeCountLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ComplianceTypeCountLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidItemContentException":
    case "com.amazonaws.ssm#InvalidItemContentException":
      response = {
        ...(await deserializeAws_json1_1InvalidItemContentExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceType":
    case "com.amazonaws.ssm#InvalidResourceType":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ItemSizeLimitExceededException":
    case "com.amazonaws.ssm#ItemSizeLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ItemSizeLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TotalSizeLimitExceededException":
    case "com.amazonaws.ssm#TotalSizeLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1TotalSizeLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1PutInventoryCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<PutInventoryCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1PutInventoryCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1PutInventoryResult(data, context);
  const response: PutInventoryCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1PutInventoryCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<PutInventoryCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "CustomSchemaCountLimitExceededException":
    case "com.amazonaws.ssm#CustomSchemaCountLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1CustomSchemaCountLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInventoryItemContextException":
    case "com.amazonaws.ssm#InvalidInventoryItemContextException":
      response = {
        ...(await deserializeAws_json1_1InvalidInventoryItemContextExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidItemContentException":
    case "com.amazonaws.ssm#InvalidItemContentException":
      response = {
        ...(await deserializeAws_json1_1InvalidItemContentExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTypeNameException":
    case "com.amazonaws.ssm#InvalidTypeNameException":
      response = {
        ...(await deserializeAws_json1_1InvalidTypeNameExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ItemContentMismatchException":
    case "com.amazonaws.ssm#ItemContentMismatchException":
      response = {
        ...(await deserializeAws_json1_1ItemContentMismatchExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ItemSizeLimitExceededException":
    case "com.amazonaws.ssm#ItemSizeLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ItemSizeLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "SubTypeCountLimitExceededException":
    case "com.amazonaws.ssm#SubTypeCountLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1SubTypeCountLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TotalSizeLimitExceededException":
    case "com.amazonaws.ssm#TotalSizeLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1TotalSizeLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedInventoryItemContextException":
    case "com.amazonaws.ssm#UnsupportedInventoryItemContextException":
      response = {
        ...(await deserializeAws_json1_1UnsupportedInventoryItemContextExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedInventorySchemaVersionException":
    case "com.amazonaws.ssm#UnsupportedInventorySchemaVersionException":
      response = {
        ...(await deserializeAws_json1_1UnsupportedInventorySchemaVersionExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1PutParameterCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<PutParameterCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1PutParameterCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1PutParameterResult(data, context);
  const response: PutParameterCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1PutParameterCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<PutParameterCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "HierarchyLevelLimitExceededException":
    case "com.amazonaws.ssm#HierarchyLevelLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1HierarchyLevelLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "HierarchyTypeMismatchException":
    case "com.amazonaws.ssm#HierarchyTypeMismatchException":
      response = {
        ...(await deserializeAws_json1_1HierarchyTypeMismatchExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "IncompatiblePolicyException":
    case "com.amazonaws.ssm#IncompatiblePolicyException":
      response = {
        ...(await deserializeAws_json1_1IncompatiblePolicyExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAllowedPatternException":
    case "com.amazonaws.ssm#InvalidAllowedPatternException":
      response = {
        ...(await deserializeAws_json1_1InvalidAllowedPatternExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidKeyId":
    case "com.amazonaws.ssm#InvalidKeyId":
      response = {
        ...(await deserializeAws_json1_1InvalidKeyIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidPolicyAttributeException":
    case "com.amazonaws.ssm#InvalidPolicyAttributeException":
      response = {
        ...(await deserializeAws_json1_1InvalidPolicyAttributeExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidPolicyTypeException":
    case "com.amazonaws.ssm#InvalidPolicyTypeException":
      response = {
        ...(await deserializeAws_json1_1InvalidPolicyTypeExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterAlreadyExists":
    case "com.amazonaws.ssm#ParameterAlreadyExists":
      response = {
        ...(await deserializeAws_json1_1ParameterAlreadyExistsResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterLimitExceeded":
    case "com.amazonaws.ssm#ParameterLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1ParameterLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterMaxVersionLimitExceeded":
    case "com.amazonaws.ssm#ParameterMaxVersionLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1ParameterMaxVersionLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ParameterPatternMismatchException":
    case "com.amazonaws.ssm#ParameterPatternMismatchException":
      response = {
        ...(await deserializeAws_json1_1ParameterPatternMismatchExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "PoliciesLimitExceededException":
    case "com.amazonaws.ssm#PoliciesLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1PoliciesLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedParameterType":
    case "com.amazonaws.ssm#UnsupportedParameterType":
      response = {
        ...(await deserializeAws_json1_1UnsupportedParameterTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1RegisterDefaultPatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterDefaultPatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1RegisterDefaultPatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1RegisterDefaultPatchBaselineResult(data, context);
  const response: RegisterDefaultPatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1RegisterDefaultPatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterDefaultPatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1RegisterPatchBaselineForPatchGroupCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterPatchBaselineForPatchGroupCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1RegisterPatchBaselineForPatchGroupCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1RegisterPatchBaselineForPatchGroupResult(data, context);
  const response: RegisterPatchBaselineForPatchGroupCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1RegisterPatchBaselineForPatchGroupCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterPatchBaselineForPatchGroupCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AlreadyExistsException":
    case "com.amazonaws.ssm#AlreadyExistsException":
      response = {
        ...(await deserializeAws_json1_1AlreadyExistsExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceLimitExceededException":
    case "com.amazonaws.ssm#ResourceLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1RegisterTargetWithMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterTargetWithMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1RegisterTargetWithMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1RegisterTargetWithMaintenanceWindowResult(data, context);
  const response: RegisterTargetWithMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1RegisterTargetWithMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterTargetWithMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "IdempotentParameterMismatch":
    case "com.amazonaws.ssm#IdempotentParameterMismatch":
      response = {
        ...(await deserializeAws_json1_1IdempotentParameterMismatchResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceLimitExceededException":
    case "com.amazonaws.ssm#ResourceLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1RegisterTaskWithMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterTaskWithMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1RegisterTaskWithMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1RegisterTaskWithMaintenanceWindowResult(data, context);
  const response: RegisterTaskWithMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1RegisterTaskWithMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RegisterTaskWithMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "FeatureNotAvailableException":
    case "com.amazonaws.ssm#FeatureNotAvailableException":
      response = {
        ...(await deserializeAws_json1_1FeatureNotAvailableExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "IdempotentParameterMismatch":
    case "com.amazonaws.ssm#IdempotentParameterMismatch":
      response = {
        ...(await deserializeAws_json1_1IdempotentParameterMismatchResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceLimitExceededException":
    case "com.amazonaws.ssm#ResourceLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1RemoveTagsFromResourceCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RemoveTagsFromResourceCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1RemoveTagsFromResourceCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1RemoveTagsFromResourceResult(data, context);
  const response: RemoveTagsFromResourceCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1RemoveTagsFromResourceCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<RemoveTagsFromResourceCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceId":
    case "com.amazonaws.ssm#InvalidResourceId":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidResourceType":
    case "com.amazonaws.ssm#InvalidResourceType":
      response = {
        ...(await deserializeAws_json1_1InvalidResourceTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ResetServiceSettingCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ResetServiceSettingCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ResetServiceSettingCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ResetServiceSettingResult(data, context);
  const response: ResetServiceSettingCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ResetServiceSettingCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ResetServiceSettingCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ServiceSettingNotFound":
    case "com.amazonaws.ssm#ServiceSettingNotFound":
      response = {
        ...(await deserializeAws_json1_1ServiceSettingNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1ResumeSessionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ResumeSessionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1ResumeSessionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1ResumeSessionResponse(data, context);
  const response: ResumeSessionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1ResumeSessionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<ResumeSessionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1SendAutomationSignalCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendAutomationSignalCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1SendAutomationSignalCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1SendAutomationSignalResult(data, context);
  const response: SendAutomationSignalCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1SendAutomationSignalCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendAutomationSignalCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AutomationExecutionNotFoundException":
    case "com.amazonaws.ssm#AutomationExecutionNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationExecutionNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "AutomationStepNotFoundException":
    case "com.amazonaws.ssm#AutomationStepNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationStepNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAutomationSignalException":
    case "com.amazonaws.ssm#InvalidAutomationSignalException":
      response = {
        ...(await deserializeAws_json1_1InvalidAutomationSignalExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1SendCommandCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendCommandCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1SendCommandCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1SendCommandResult(data, context);
  const response: SendCommandCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1SendCommandCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendCommandCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DuplicateInstanceId":
    case "com.amazonaws.ssm#DuplicateInstanceId":
      response = {
        ...(await deserializeAws_json1_1DuplicateInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidNotificationConfig":
    case "com.amazonaws.ssm#InvalidNotificationConfig":
      response = {
        ...(await deserializeAws_json1_1InvalidNotificationConfigResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidOutputFolder":
    case "com.amazonaws.ssm#InvalidOutputFolder":
      response = {
        ...(await deserializeAws_json1_1InvalidOutputFolderResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidParameters":
    case "com.amazonaws.ssm#InvalidParameters":
      response = {
        ...(await deserializeAws_json1_1InvalidParametersResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidRole":
    case "com.amazonaws.ssm#InvalidRole":
      response = {
        ...(await deserializeAws_json1_1InvalidRoleResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "MaxDocumentSizeExceeded":
    case "com.amazonaws.ssm#MaxDocumentSizeExceeded":
      response = {
        ...(await deserializeAws_json1_1MaxDocumentSizeExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "UnsupportedPlatformType":
    case "com.amazonaws.ssm#UnsupportedPlatformType":
      response = {
        ...(await deserializeAws_json1_1UnsupportedPlatformTypeResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1StartAssociationsOnceCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StartAssociationsOnceCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1StartAssociationsOnceCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1StartAssociationsOnceResult(data, context);
  const response: StartAssociationsOnceCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1StartAssociationsOnceCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StartAssociationsOnceCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAssociation":
    case "com.amazonaws.ssm#InvalidAssociation":
      response = {
        ...(await deserializeAws_json1_1InvalidAssociationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1StartAutomationExecutionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StartAutomationExecutionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1StartAutomationExecutionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1StartAutomationExecutionResult(data, context);
  const response: StartAutomationExecutionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1StartAutomationExecutionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StartAutomationExecutionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AutomationDefinitionNotFoundException":
    case "com.amazonaws.ssm#AutomationDefinitionNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationDefinitionNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "AutomationDefinitionVersionNotFoundException":
    case "com.amazonaws.ssm#AutomationDefinitionVersionNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationDefinitionVersionNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "AutomationExecutionLimitExceededException":
    case "com.amazonaws.ssm#AutomationExecutionLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1AutomationExecutionLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "IdempotentParameterMismatch":
    case "com.amazonaws.ssm#IdempotentParameterMismatch":
      response = {
        ...(await deserializeAws_json1_1IdempotentParameterMismatchResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAutomationExecutionParametersException":
    case "com.amazonaws.ssm#InvalidAutomationExecutionParametersException":
      response = {
        ...(await deserializeAws_json1_1InvalidAutomationExecutionParametersExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTarget":
    case "com.amazonaws.ssm#InvalidTarget":
      response = {
        ...(await deserializeAws_json1_1InvalidTargetResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1StartSessionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StartSessionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1StartSessionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1StartSessionResponse(data, context);
  const response: StartSessionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1StartSessionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StartSessionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TargetNotConnected":
    case "com.amazonaws.ssm#TargetNotConnected":
      response = {
        ...(await deserializeAws_json1_1TargetNotConnectedResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1StopAutomationExecutionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StopAutomationExecutionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1StopAutomationExecutionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1StopAutomationExecutionResult(data, context);
  const response: StopAutomationExecutionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1StopAutomationExecutionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<StopAutomationExecutionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AutomationExecutionNotFoundException":
    case "com.amazonaws.ssm#AutomationExecutionNotFoundException":
      response = {
        ...(await deserializeAws_json1_1AutomationExecutionNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAutomationStatusUpdateException":
    case "com.amazonaws.ssm#InvalidAutomationStatusUpdateException":
      response = {
        ...(await deserializeAws_json1_1InvalidAutomationStatusUpdateExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1TerminateSessionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<TerminateSessionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1TerminateSessionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1TerminateSessionResponse(data, context);
  const response: TerminateSessionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1TerminateSessionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<TerminateSessionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateAssociationCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateAssociationCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateAssociationCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateAssociationResult(data, context);
  const response: UpdateAssociationCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateAssociationCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateAssociationCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "AssociationVersionLimitExceeded":
    case "com.amazonaws.ssm#AssociationVersionLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1AssociationVersionLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidAssociationVersion":
    case "com.amazonaws.ssm#InvalidAssociationVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidAssociationVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidOutputLocation":
    case "com.amazonaws.ssm#InvalidOutputLocation":
      response = {
        ...(await deserializeAws_json1_1InvalidOutputLocationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidParameters":
    case "com.amazonaws.ssm#InvalidParameters":
      response = {
        ...(await deserializeAws_json1_1InvalidParametersResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidSchedule":
    case "com.amazonaws.ssm#InvalidSchedule":
      response = {
        ...(await deserializeAws_json1_1InvalidScheduleResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidTarget":
    case "com.amazonaws.ssm#InvalidTarget":
      response = {
        ...(await deserializeAws_json1_1InvalidTargetResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidUpdate":
    case "com.amazonaws.ssm#InvalidUpdate":
      response = {
        ...(await deserializeAws_json1_1InvalidUpdateResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateAssociationStatusCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateAssociationStatusCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateAssociationStatusCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateAssociationStatusResult(data, context);
  const response: UpdateAssociationStatusCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateAssociationStatusCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateAssociationStatusCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "AssociationDoesNotExist":
    case "com.amazonaws.ssm#AssociationDoesNotExist":
      response = {
        ...(await deserializeAws_json1_1AssociationDoesNotExistResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "StatusUnchanged":
    case "com.amazonaws.ssm#StatusUnchanged":
      response = {
        ...(await deserializeAws_json1_1StatusUnchangedResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateDocumentCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateDocumentCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateDocumentCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateDocumentResult(data, context);
  const response: UpdateDocumentCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateDocumentCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateDocumentCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DocumentVersionLimitExceeded":
    case "com.amazonaws.ssm#DocumentVersionLimitExceeded":
      response = {
        ...(await deserializeAws_json1_1DocumentVersionLimitExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "DuplicateDocumentContent":
    case "com.amazonaws.ssm#DuplicateDocumentContent":
      response = {
        ...(await deserializeAws_json1_1DuplicateDocumentContentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "DuplicateDocumentVersionName":
    case "com.amazonaws.ssm#DuplicateDocumentVersionName":
      response = {
        ...(await deserializeAws_json1_1DuplicateDocumentVersionNameResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentContent":
    case "com.amazonaws.ssm#InvalidDocumentContent":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentContentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentOperation":
    case "com.amazonaws.ssm#InvalidDocumentOperation":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentOperationResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentSchemaVersion":
    case "com.amazonaws.ssm#InvalidDocumentSchemaVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentSchemaVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "MaxDocumentSizeExceeded":
    case "com.amazonaws.ssm#MaxDocumentSizeExceeded":
      response = {
        ...(await deserializeAws_json1_1MaxDocumentSizeExceededResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateDocumentDefaultVersionCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateDocumentDefaultVersionCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateDocumentDefaultVersionCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateDocumentDefaultVersionResult(data, context);
  const response: UpdateDocumentDefaultVersionCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateDocumentDefaultVersionCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateDocumentDefaultVersionCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocument":
    case "com.amazonaws.ssm#InvalidDocument":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentSchemaVersion":
    case "com.amazonaws.ssm#InvalidDocumentSchemaVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentSchemaVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidDocumentVersion":
    case "com.amazonaws.ssm#InvalidDocumentVersion":
      response = {
        ...(await deserializeAws_json1_1InvalidDocumentVersionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateMaintenanceWindowCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateMaintenanceWindowCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateMaintenanceWindowCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateMaintenanceWindowResult(data, context);
  const response: UpdateMaintenanceWindowCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateMaintenanceWindowCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateMaintenanceWindowCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateMaintenanceWindowTargetCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateMaintenanceWindowTargetCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateMaintenanceWindowTargetCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateMaintenanceWindowTargetResult(data, context);
  const response: UpdateMaintenanceWindowTargetCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateMaintenanceWindowTargetCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateMaintenanceWindowTargetCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateMaintenanceWindowTaskCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateMaintenanceWindowTaskCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateMaintenanceWindowTaskCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateMaintenanceWindowTaskResult(data, context);
  const response: UpdateMaintenanceWindowTaskCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateMaintenanceWindowTaskCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateMaintenanceWindowTaskCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateManagedInstanceRoleCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateManagedInstanceRoleCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateManagedInstanceRoleCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateManagedInstanceRoleResult(data, context);
  const response: UpdateManagedInstanceRoleCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateManagedInstanceRoleCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateManagedInstanceRoleCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidInstanceId":
    case "com.amazonaws.ssm#InvalidInstanceId":
      response = {
        ...(await deserializeAws_json1_1InvalidInstanceIdResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateOpsItemCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateOpsItemCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateOpsItemCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateOpsItemResponse(data, context);
  const response: UpdateOpsItemCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateOpsItemCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateOpsItemCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemAlreadyExistsException":
    case "com.amazonaws.ssm#OpsItemAlreadyExistsException":
      response = {
        ...(await deserializeAws_json1_1OpsItemAlreadyExistsExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemInvalidParameterException":
    case "com.amazonaws.ssm#OpsItemInvalidParameterException":
      response = {
        ...(await deserializeAws_json1_1OpsItemInvalidParameterExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemLimitExceededException":
    case "com.amazonaws.ssm#OpsItemLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1OpsItemLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "OpsItemNotFoundException":
    case "com.amazonaws.ssm#OpsItemNotFoundException":
      response = {
        ...(await deserializeAws_json1_1OpsItemNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdatePatchBaselineCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdatePatchBaselineCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdatePatchBaselineCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdatePatchBaselineResult(data, context);
  const response: UpdatePatchBaselineCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdatePatchBaselineCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdatePatchBaselineCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "DoesNotExistException":
    case "com.amazonaws.ssm#DoesNotExistException":
      response = {
        ...(await deserializeAws_json1_1DoesNotExistExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateResourceDataSyncCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateResourceDataSyncCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateResourceDataSyncCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateResourceDataSyncResult(data, context);
  const response: UpdateResourceDataSyncCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateResourceDataSyncCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateResourceDataSyncCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncConflictException":
    case "com.amazonaws.ssm#ResourceDataSyncConflictException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncConflictExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncInvalidConfigurationException":
    case "com.amazonaws.ssm#ResourceDataSyncInvalidConfigurationException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncInvalidConfigurationExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ResourceDataSyncNotFoundException":
    case "com.amazonaws.ssm#ResourceDataSyncNotFoundException":
      response = {
        ...(await deserializeAws_json1_1ResourceDataSyncNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

export const deserializeAws_json1_1UpdateServiceSettingCommand = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateServiceSettingCommandOutput> => {
  if (output.statusCode >= 400) {
    return deserializeAws_json1_1UpdateServiceSettingCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1UpdateServiceSettingResult(data, context);
  const response: UpdateServiceSettingCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
};

const deserializeAws_json1_1UpdateServiceSettingCommandError = async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<UpdateServiceSettingCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode: string = "UnknownError";
  const errorTypeParts: String = parsedOutput.body["__type"].split("#");
  errorCode = errorTypeParts[1] === undefined ? errorTypeParts[0] : errorTypeParts[1];
  switch (errorCode) {
    case "InternalServerError":
    case "com.amazonaws.ssm#InternalServerError":
      response = {
        ...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ServiceSettingNotFound":
    case "com.amazonaws.ssm#ServiceSettingNotFound":
      response = {
        ...(await deserializeAws_json1_1ServiceSettingNotFoundResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "TooManyUpdates":
    case "com.amazonaws.ssm#TooManyUpdates":
      response = {
        ...(await deserializeAws_json1_1TooManyUpdatesResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
};

const deserializeAws_json1_1AlreadyExistsExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AlreadyExistsException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AlreadyExistsException(body, context);
  const contents: AlreadyExistsException = {
    name: "AlreadyExistsException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AssociatedInstancesResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AssociatedInstances> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AssociatedInstances(body, context);
  const contents: AssociatedInstances = {
    name: "AssociatedInstances",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AssociationAlreadyExistsResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AssociationAlreadyExists> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AssociationAlreadyExists(body, context);
  const contents: AssociationAlreadyExists = {
    name: "AssociationAlreadyExists",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AssociationDoesNotExistResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AssociationDoesNotExist> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AssociationDoesNotExist(body, context);
  const contents: AssociationDoesNotExist = {
    name: "AssociationDoesNotExist",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AssociationExecutionDoesNotExistResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AssociationExecutionDoesNotExist> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AssociationExecutionDoesNotExist(body, context);
  const contents: AssociationExecutionDoesNotExist = {
    name: "AssociationExecutionDoesNotExist",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AssociationLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AssociationLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AssociationLimitExceeded(body, context);
  const contents: AssociationLimitExceeded = {
    name: "AssociationLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AssociationVersionLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AssociationVersionLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AssociationVersionLimitExceeded(body, context);
  const contents: AssociationVersionLimitExceeded = {
    name: "AssociationVersionLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AutomationDefinitionNotFoundExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AutomationDefinitionNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AutomationDefinitionNotFoundException(body, context);
  const contents: AutomationDefinitionNotFoundException = {
    name: "AutomationDefinitionNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AutomationDefinitionVersionNotFoundExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AutomationDefinitionVersionNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AutomationDefinitionVersionNotFoundException(body, context);
  const contents: AutomationDefinitionVersionNotFoundException = {
    name: "AutomationDefinitionVersionNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AutomationExecutionLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AutomationExecutionLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AutomationExecutionLimitExceededException(body, context);
  const contents: AutomationExecutionLimitExceededException = {
    name: "AutomationExecutionLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AutomationExecutionNotFoundExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AutomationExecutionNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AutomationExecutionNotFoundException(body, context);
  const contents: AutomationExecutionNotFoundException = {
    name: "AutomationExecutionNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1AutomationStepNotFoundExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AutomationStepNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AutomationStepNotFoundException(body, context);
  const contents: AutomationStepNotFoundException = {
    name: "AutomationStepNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ComplianceTypeCountLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ComplianceTypeCountLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ComplianceTypeCountLimitExceededException(body, context);
  const contents: ComplianceTypeCountLimitExceededException = {
    name: "ComplianceTypeCountLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1CustomSchemaCountLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<CustomSchemaCountLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1CustomSchemaCountLimitExceededException(body, context);
  const contents: CustomSchemaCountLimitExceededException = {
    name: "CustomSchemaCountLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DocumentAlreadyExistsResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DocumentAlreadyExists> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DocumentAlreadyExists(body, context);
  const contents: DocumentAlreadyExists = {
    name: "DocumentAlreadyExists",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DocumentLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DocumentLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DocumentLimitExceeded(body, context);
  const contents: DocumentLimitExceeded = {
    name: "DocumentLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DocumentPermissionLimitResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DocumentPermissionLimit> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DocumentPermissionLimit(body, context);
  const contents: DocumentPermissionLimit = {
    name: "DocumentPermissionLimit",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DocumentVersionLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DocumentVersionLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DocumentVersionLimitExceeded(body, context);
  const contents: DocumentVersionLimitExceeded = {
    name: "DocumentVersionLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DoesNotExistExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DoesNotExistException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DoesNotExistException(body, context);
  const contents: DoesNotExistException = {
    name: "DoesNotExistException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DuplicateDocumentContentResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DuplicateDocumentContent> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DuplicateDocumentContent(body, context);
  const contents: DuplicateDocumentContent = {
    name: "DuplicateDocumentContent",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DuplicateDocumentVersionNameResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DuplicateDocumentVersionName> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DuplicateDocumentVersionName(body, context);
  const contents: DuplicateDocumentVersionName = {
    name: "DuplicateDocumentVersionName",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1DuplicateInstanceIdResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<DuplicateInstanceId> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1DuplicateInstanceId(body, context);
  const contents: DuplicateInstanceId = {
    name: "DuplicateInstanceId",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1FeatureNotAvailableExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<FeatureNotAvailableException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1FeatureNotAvailableException(body, context);
  const contents: FeatureNotAvailableException = {
    name: "FeatureNotAvailableException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1HierarchyLevelLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<HierarchyLevelLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1HierarchyLevelLimitExceededException(body, context);
  const contents: HierarchyLevelLimitExceededException = {
    name: "HierarchyLevelLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1HierarchyTypeMismatchExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<HierarchyTypeMismatchException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1HierarchyTypeMismatchException(body, context);
  const contents: HierarchyTypeMismatchException = {
    name: "HierarchyTypeMismatchException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1IdempotentParameterMismatchResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<IdempotentParameterMismatch> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1IdempotentParameterMismatch(body, context);
  const contents: IdempotentParameterMismatch = {
    name: "IdempotentParameterMismatch",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1IncompatiblePolicyExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<IncompatiblePolicyException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1IncompatiblePolicyException(body, context);
  const contents: IncompatiblePolicyException = {
    name: "IncompatiblePolicyException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InternalServerErrorResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InternalServerError> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InternalServerError(body, context);
  const contents: InternalServerError = {
    name: "InternalServerError",
    $fault: "server",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidActivationResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidActivation> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidActivation(body, context);
  const contents: InvalidActivation = {
    name: "InvalidActivation",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidActivationIdResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidActivationId> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidActivationId(body, context);
  const contents: InvalidActivationId = {
    name: "InvalidActivationId",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAggregatorExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAggregatorException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAggregatorException(body, context);
  const contents: InvalidAggregatorException = {
    name: "InvalidAggregatorException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAllowedPatternExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAllowedPatternException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAllowedPatternException(body, context);
  const contents: InvalidAllowedPatternException = {
    name: "InvalidAllowedPatternException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAssociationResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAssociation> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAssociation(body, context);
  const contents: InvalidAssociation = {
    name: "InvalidAssociation",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAssociationVersionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAssociationVersion> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAssociationVersion(body, context);
  const contents: InvalidAssociationVersion = {
    name: "InvalidAssociationVersion",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAutomationExecutionParametersExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAutomationExecutionParametersException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAutomationExecutionParametersException(body, context);
  const contents: InvalidAutomationExecutionParametersException = {
    name: "InvalidAutomationExecutionParametersException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAutomationSignalExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAutomationSignalException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAutomationSignalException(body, context);
  const contents: InvalidAutomationSignalException = {
    name: "InvalidAutomationSignalException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidAutomationStatusUpdateExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidAutomationStatusUpdateException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidAutomationStatusUpdateException(body, context);
  const contents: InvalidAutomationStatusUpdateException = {
    name: "InvalidAutomationStatusUpdateException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidCommandIdResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidCommandId> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidCommandId(body, context);
  const contents: InvalidCommandId = {
    name: "InvalidCommandId",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDeleteInventoryParametersExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDeleteInventoryParametersException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDeleteInventoryParametersException(body, context);
  const contents: InvalidDeleteInventoryParametersException = {
    name: "InvalidDeleteInventoryParametersException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDeletionIdExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDeletionIdException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDeletionIdException(body, context);
  const contents: InvalidDeletionIdException = {
    name: "InvalidDeletionIdException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDocumentResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDocument> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDocument(body, context);
  const contents: InvalidDocument = {
    name: "InvalidDocument",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDocumentContentResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDocumentContent> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDocumentContent(body, context);
  const contents: InvalidDocumentContent = {
    name: "InvalidDocumentContent",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDocumentOperationResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDocumentOperation> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDocumentOperation(body, context);
  const contents: InvalidDocumentOperation = {
    name: "InvalidDocumentOperation",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDocumentSchemaVersionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDocumentSchemaVersion> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDocumentSchemaVersion(body, context);
  const contents: InvalidDocumentSchemaVersion = {
    name: "InvalidDocumentSchemaVersion",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDocumentTypeResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDocumentType> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDocumentType(body, context);
  const contents: InvalidDocumentType = {
    name: "InvalidDocumentType",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidDocumentVersionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidDocumentVersion> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidDocumentVersion(body, context);
  const contents: InvalidDocumentVersion = {
    name: "InvalidDocumentVersion",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidFilterResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidFilter> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidFilter(body, context);
  const contents: InvalidFilter = {
    name: "InvalidFilter",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidFilterKeyResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidFilterKey> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidFilterKey(body, context);
  const contents: InvalidFilterKey = {
    name: "InvalidFilterKey",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidFilterOptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidFilterOption> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidFilterOption(body, context);
  const contents: InvalidFilterOption = {
    name: "InvalidFilterOption",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidFilterValueResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidFilterValue> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidFilterValue(body, context);
  const contents: InvalidFilterValue = {
    name: "InvalidFilterValue",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidInstanceIdResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidInstanceId> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidInstanceId(body, context);
  const contents: InvalidInstanceId = {
    name: "InvalidInstanceId",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidInstanceInformationFilterValueResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidInstanceInformationFilterValue> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidInstanceInformationFilterValue(body, context);
  const contents: InvalidInstanceInformationFilterValue = {
    name: "InvalidInstanceInformationFilterValue",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidInventoryGroupExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidInventoryGroupException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidInventoryGroupException(body, context);
  const contents: InvalidInventoryGroupException = {
    name: "InvalidInventoryGroupException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidInventoryItemContextExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidInventoryItemContextException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidInventoryItemContextException(body, context);
  const contents: InvalidInventoryItemContextException = {
    name: "InvalidInventoryItemContextException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidInventoryRequestExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidInventoryRequestException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidInventoryRequestException(body, context);
  const contents: InvalidInventoryRequestException = {
    name: "InvalidInventoryRequestException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidItemContentExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidItemContentException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidItemContentException(body, context);
  const contents: InvalidItemContentException = {
    name: "InvalidItemContentException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidKeyIdResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidKeyId> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidKeyId(body, context);
  const contents: InvalidKeyId = {
    name: "InvalidKeyId",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidNextTokenResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidNextToken> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidNextToken(body, context);
  const contents: InvalidNextToken = {
    name: "InvalidNextToken",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidNotificationConfigResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidNotificationConfig> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidNotificationConfig(body, context);
  const contents: InvalidNotificationConfig = {
    name: "InvalidNotificationConfig",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidOptionExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidOptionException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidOptionException(body, context);
  const contents: InvalidOptionException = {
    name: "InvalidOptionException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidOutputFolderResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidOutputFolder> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidOutputFolder(body, context);
  const contents: InvalidOutputFolder = {
    name: "InvalidOutputFolder",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidOutputLocationResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidOutputLocation> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidOutputLocation(body, context);
  const contents: InvalidOutputLocation = {
    name: "InvalidOutputLocation",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidParametersResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidParameters> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidParameters(body, context);
  const contents: InvalidParameters = {
    name: "InvalidParameters",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidPermissionTypeResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidPermissionType> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidPermissionType(body, context);
  const contents: InvalidPermissionType = {
    name: "InvalidPermissionType",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidPluginNameResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidPluginName> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidPluginName(body, context);
  const contents: InvalidPluginName = {
    name: "InvalidPluginName",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidPolicyAttributeExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidPolicyAttributeException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidPolicyAttributeException(body, context);
  const contents: InvalidPolicyAttributeException = {
    name: "InvalidPolicyAttributeException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidPolicyTypeExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidPolicyTypeException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidPolicyTypeException(body, context);
  const contents: InvalidPolicyTypeException = {
    name: "InvalidPolicyTypeException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidResourceIdResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidResourceId> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidResourceId(body, context);
  const contents: InvalidResourceId = {
    name: "InvalidResourceId",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidResourceTypeResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidResourceType> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidResourceType(body, context);
  const contents: InvalidResourceType = {
    name: "InvalidResourceType",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidResultAttributeExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidResultAttributeException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidResultAttributeException(body, context);
  const contents: InvalidResultAttributeException = {
    name: "InvalidResultAttributeException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidRoleResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidRole> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidRole(body, context);
  const contents: InvalidRole = {
    name: "InvalidRole",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidScheduleResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidSchedule> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidSchedule(body, context);
  const contents: InvalidSchedule = {
    name: "InvalidSchedule",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidTargetResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidTarget> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidTarget(body, context);
  const contents: InvalidTarget = {
    name: "InvalidTarget",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidTypeNameExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidTypeNameException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidTypeNameException(body, context);
  const contents: InvalidTypeNameException = {
    name: "InvalidTypeNameException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvalidUpdateResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidUpdate> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidUpdate(body, context);
  const contents: InvalidUpdate = {
    name: "InvalidUpdate",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1InvocationDoesNotExistResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvocationDoesNotExist> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvocationDoesNotExist(body, context);
  const contents: InvocationDoesNotExist = {
    name: "InvocationDoesNotExist",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ItemContentMismatchExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ItemContentMismatchException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ItemContentMismatchException(body, context);
  const contents: ItemContentMismatchException = {
    name: "ItemContentMismatchException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ItemSizeLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ItemSizeLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ItemSizeLimitExceededException(body, context);
  const contents: ItemSizeLimitExceededException = {
    name: "ItemSizeLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1MaxDocumentSizeExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<MaxDocumentSizeExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1MaxDocumentSizeExceeded(body, context);
  const contents: MaxDocumentSizeExceeded = {
    name: "MaxDocumentSizeExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1OpsItemAlreadyExistsExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<OpsItemAlreadyExistsException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1OpsItemAlreadyExistsException(body, context);
  const contents: OpsItemAlreadyExistsException = {
    name: "OpsItemAlreadyExistsException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1OpsItemInvalidParameterExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<OpsItemInvalidParameterException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1OpsItemInvalidParameterException(body, context);
  const contents: OpsItemInvalidParameterException = {
    name: "OpsItemInvalidParameterException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1OpsItemLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<OpsItemLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1OpsItemLimitExceededException(body, context);
  const contents: OpsItemLimitExceededException = {
    name: "OpsItemLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1OpsItemNotFoundExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<OpsItemNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1OpsItemNotFoundException(body, context);
  const contents: OpsItemNotFoundException = {
    name: "OpsItemNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterAlreadyExistsResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterAlreadyExists> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterAlreadyExists(body, context);
  const contents: ParameterAlreadyExists = {
    name: "ParameterAlreadyExists",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterLimitExceeded(body, context);
  const contents: ParameterLimitExceeded = {
    name: "ParameterLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterMaxVersionLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterMaxVersionLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterMaxVersionLimitExceeded(body, context);
  const contents: ParameterMaxVersionLimitExceeded = {
    name: "ParameterMaxVersionLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterNotFoundResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterNotFound> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterNotFound(body, context);
  const contents: ParameterNotFound = {
    name: "ParameterNotFound",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterPatternMismatchExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterPatternMismatchException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterPatternMismatchException(body, context);
  const contents: ParameterPatternMismatchException = {
    name: "ParameterPatternMismatchException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterVersionLabelLimitExceededResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterVersionLabelLimitExceeded> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterVersionLabelLimitExceeded(body, context);
  const contents: ParameterVersionLabelLimitExceeded = {
    name: "ParameterVersionLabelLimitExceeded",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ParameterVersionNotFoundResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ParameterVersionNotFound> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ParameterVersionNotFound(body, context);
  const contents: ParameterVersionNotFound = {
    name: "ParameterVersionNotFound",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1PoliciesLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<PoliciesLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1PoliciesLimitExceededException(body, context);
  const contents: PoliciesLimitExceededException = {
    name: "PoliciesLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceDataSyncAlreadyExistsExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceDataSyncAlreadyExistsException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceDataSyncAlreadyExistsException(body, context);
  const contents: ResourceDataSyncAlreadyExistsException = {
    name: "ResourceDataSyncAlreadyExistsException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceDataSyncConflictExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceDataSyncConflictException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceDataSyncConflictException(body, context);
  const contents: ResourceDataSyncConflictException = {
    name: "ResourceDataSyncConflictException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceDataSyncCountExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceDataSyncCountExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceDataSyncCountExceededException(body, context);
  const contents: ResourceDataSyncCountExceededException = {
    name: "ResourceDataSyncCountExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceDataSyncInvalidConfigurationExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceDataSyncInvalidConfigurationException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceDataSyncInvalidConfigurationException(body, context);
  const contents: ResourceDataSyncInvalidConfigurationException = {
    name: "ResourceDataSyncInvalidConfigurationException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceDataSyncNotFoundExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceDataSyncNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceDataSyncNotFoundException(body, context);
  const contents: ResourceDataSyncNotFoundException = {
    name: "ResourceDataSyncNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceInUseExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceInUseException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceInUseException(body, context);
  const contents: ResourceInUseException = {
    name: "ResourceInUseException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ResourceLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ResourceLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ResourceLimitExceededException(body, context);
  const contents: ResourceLimitExceededException = {
    name: "ResourceLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1ServiceSettingNotFoundResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ServiceSettingNotFound> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ServiceSettingNotFound(body, context);
  const contents: ServiceSettingNotFound = {
    name: "ServiceSettingNotFound",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1StatusUnchangedResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<StatusUnchanged> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1StatusUnchanged(body, context);
  const contents: StatusUnchanged = {
    name: "StatusUnchanged",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1SubTypeCountLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<SubTypeCountLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1SubTypeCountLimitExceededException(body, context);
  const contents: SubTypeCountLimitExceededException = {
    name: "SubTypeCountLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1TargetInUseExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<TargetInUseException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1TargetInUseException(body, context);
  const contents: TargetInUseException = {
    name: "TargetInUseException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1TargetNotConnectedResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<TargetNotConnected> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1TargetNotConnected(body, context);
  const contents: TargetNotConnected = {
    name: "TargetNotConnected",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1TooManyTagsErrorResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<TooManyTagsError> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1TooManyTagsError(body, context);
  const contents: TooManyTagsError = {
    name: "TooManyTagsError",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1TooManyUpdatesResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<TooManyUpdates> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1TooManyUpdates(body, context);
  const contents: TooManyUpdates = {
    name: "TooManyUpdates",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1TotalSizeLimitExceededExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<TotalSizeLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1TotalSizeLimitExceededException(body, context);
  const contents: TotalSizeLimitExceededException = {
    name: "TotalSizeLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedCalendarExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedCalendarException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedCalendarException(body, context);
  const contents: UnsupportedCalendarException = {
    name: "UnsupportedCalendarException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedFeatureRequiredExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedFeatureRequiredException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedFeatureRequiredException(body, context);
  const contents: UnsupportedFeatureRequiredException = {
    name: "UnsupportedFeatureRequiredException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedInventoryItemContextExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedInventoryItemContextException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedInventoryItemContextException(body, context);
  const contents: UnsupportedInventoryItemContextException = {
    name: "UnsupportedInventoryItemContextException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedInventorySchemaVersionExceptionResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedInventorySchemaVersionException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedInventorySchemaVersionException(body, context);
  const contents: UnsupportedInventorySchemaVersionException = {
    name: "UnsupportedInventorySchemaVersionException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedOperatingSystemResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedOperatingSystem> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedOperatingSystem(body, context);
  const contents: UnsupportedOperatingSystem = {
    name: "UnsupportedOperatingSystem",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedParameterTypeResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedParameterType> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedParameterType(body, context);
  const contents: UnsupportedParameterType = {
    name: "UnsupportedParameterType",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const deserializeAws_json1_1UnsupportedPlatformTypeResponse = async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<UnsupportedPlatformType> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1UnsupportedPlatformType(body, context);
  const contents: UnsupportedPlatformType = {
    name: "UnsupportedPlatformType",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
};

const serializeAws_json1_1AccountIdList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1Accounts = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1AddTagsToResourceRequest = (
  input: AddTagsToResourceRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ResourceId !== undefined && { ResourceId: input.ResourceId }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
  };
};

const serializeAws_json1_1AssociationExecutionFilter = (
  input: AssociationExecutionFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Value !== undefined && { Value: input.Value }),
  };
};

const serializeAws_json1_1AssociationExecutionFilterList = (
  input: AssociationExecutionFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1AssociationExecutionFilter(entry, context));
};

const serializeAws_json1_1AssociationExecutionTargetsFilter = (
  input: AssociationExecutionTargetsFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Value !== undefined && { Value: input.Value }),
  };
};

const serializeAws_json1_1AssociationExecutionTargetsFilterList = (
  input: AssociationExecutionTargetsFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1AssociationExecutionTargetsFilter(entry, context));
};

const serializeAws_json1_1AssociationFilter = (input: AssociationFilter, context: __SerdeContext): any => {
  return {
    ...(input.key !== undefined && { key: input.key }),
    ...(input.value !== undefined && { value: input.value }),
  };
};

const serializeAws_json1_1AssociationFilterList = (input: AssociationFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1AssociationFilter(entry, context));
};

const serializeAws_json1_1AssociationIdList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1AssociationStatus = (input: AssociationStatus, context: __SerdeContext): any => {
  return {
    ...(input.AdditionalInfo !== undefined && { AdditionalInfo: input.AdditionalInfo }),
    ...(input.Date !== undefined && { Date: Math.round(input.Date.getTime() / 1000) }),
    ...(input.Message !== undefined && { Message: input.Message }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1AttachmentsSource = (input: AttachmentsSource, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1AttachmentsSourceValues(input.Values, context) }),
  };
};

const serializeAws_json1_1AttachmentsSourceList = (input: AttachmentsSource[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1AttachmentsSource(entry, context));
};

const serializeAws_json1_1AttachmentsSourceValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1AutomationExecutionFilter = (
  input: AutomationExecutionFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1AutomationExecutionFilterValueList(input.Values, context),
    }),
  };
};

const serializeAws_json1_1AutomationExecutionFilterList = (
  input: AutomationExecutionFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1AutomationExecutionFilter(entry, context));
};

const serializeAws_json1_1AutomationExecutionFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1AutomationParameterMap = (
  input: { [key: string]: string[] },
  context: __SerdeContext
): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: serializeAws_json1_1AutomationParameterValueList(value, context),
    }),
    {}
  );
};

const serializeAws_json1_1AutomationParameterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1CalendarNameOrARNList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1CancelCommandRequest = (input: CancelCommandRequest, context: __SerdeContext): any => {
  return {
    ...(input.CommandId !== undefined && { CommandId: input.CommandId }),
    ...(input.InstanceIds !== undefined && {
      InstanceIds: serializeAws_json1_1InstanceIdList(input.InstanceIds, context),
    }),
  };
};

const serializeAws_json1_1CancelMaintenanceWindowExecutionRequest = (
  input: CancelMaintenanceWindowExecutionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.WindowExecutionId !== undefined && { WindowExecutionId: input.WindowExecutionId }),
  };
};

const serializeAws_json1_1CloudWatchOutputConfig = (input: CloudWatchOutputConfig, context: __SerdeContext): any => {
  return {
    ...(input.CloudWatchLogGroupName !== undefined && { CloudWatchLogGroupName: input.CloudWatchLogGroupName }),
    ...(input.CloudWatchOutputEnabled !== undefined && { CloudWatchOutputEnabled: input.CloudWatchOutputEnabled }),
  };
};

const serializeAws_json1_1CommandFilter = (input: CommandFilter, context: __SerdeContext): any => {
  return {
    ...(input.key !== undefined && { key: input.key }),
    ...(input.value !== undefined && { value: input.value }),
  };
};

const serializeAws_json1_1CommandFilterList = (input: CommandFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1CommandFilter(entry, context));
};

const serializeAws_json1_1ComplianceExecutionSummary = (
  input: ComplianceExecutionSummary,
  context: __SerdeContext
): any => {
  return {
    ...(input.ExecutionId !== undefined && { ExecutionId: input.ExecutionId }),
    ...(input.ExecutionTime !== undefined && { ExecutionTime: Math.round(input.ExecutionTime.getTime() / 1000) }),
    ...(input.ExecutionType !== undefined && { ExecutionType: input.ExecutionType }),
  };
};

const serializeAws_json1_1ComplianceItemDetails = (input: { [key: string]: string }, context: __SerdeContext): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const serializeAws_json1_1ComplianceItemEntry = (input: ComplianceItemEntry, context: __SerdeContext): any => {
  return {
    ...(input.Details !== undefined && { Details: serializeAws_json1_1ComplianceItemDetails(input.Details, context) }),
    ...(input.Id !== undefined && { Id: input.Id }),
    ...(input.Severity !== undefined && { Severity: input.Severity }),
    ...(input.Status !== undefined && { Status: input.Status }),
    ...(input.Title !== undefined && { Title: input.Title }),
  };
};

const serializeAws_json1_1ComplianceItemEntryList = (input: ComplianceItemEntry[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1ComplianceItemEntry(entry, context));
};

const serializeAws_json1_1ComplianceResourceIdList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ComplianceResourceTypeList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ComplianceStringFilter = (input: ComplianceStringFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1ComplianceStringFilterValueList(input.Values, context),
    }),
  };
};

const serializeAws_json1_1ComplianceStringFilterList = (
  input: ComplianceStringFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1ComplianceStringFilter(entry, context));
};

const serializeAws_json1_1ComplianceStringFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1CreateActivationRequest = (input: CreateActivationRequest, context: __SerdeContext): any => {
  return {
    ...(input.DefaultInstanceName !== undefined && { DefaultInstanceName: input.DefaultInstanceName }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.ExpirationDate !== undefined && { ExpirationDate: Math.round(input.ExpirationDate.getTime() / 1000) }),
    ...(input.IamRole !== undefined && { IamRole: input.IamRole }),
    ...(input.RegistrationLimit !== undefined && { RegistrationLimit: input.RegistrationLimit }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
  };
};

const serializeAws_json1_1CreateAssociationBatchRequest = (
  input: CreateAssociationBatchRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Entries !== undefined && {
      Entries: serializeAws_json1_1CreateAssociationBatchRequestEntries(input.Entries, context),
    }),
  };
};

const serializeAws_json1_1CreateAssociationBatchRequestEntries = (
  input: CreateAssociationBatchRequestEntry[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1CreateAssociationBatchRequestEntry(entry, context));
};

const serializeAws_json1_1CreateAssociationBatchRequestEntry = (
  input: CreateAssociationBatchRequestEntry,
  context: __SerdeContext
): any => {
  return {
    ...(input.ApplyOnlyAtCronInterval !== undefined && { ApplyOnlyAtCronInterval: input.ApplyOnlyAtCronInterval }),
    ...(input.AssociationName !== undefined && { AssociationName: input.AssociationName }),
    ...(input.AutomationTargetParameterName !== undefined && {
      AutomationTargetParameterName: input.AutomationTargetParameterName,
    }),
    ...(input.ComplianceSeverity !== undefined && { ComplianceSeverity: input.ComplianceSeverity }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.OutputLocation !== undefined && {
      OutputLocation: serializeAws_json1_1InstanceAssociationOutputLocation(input.OutputLocation, context),
    }),
    ...(input.Parameters !== undefined && { Parameters: serializeAws_json1_1Parameters(input.Parameters, context) }),
    ...(input.ScheduleExpression !== undefined && { ScheduleExpression: input.ScheduleExpression }),
    ...(input.SyncCompliance !== undefined && { SyncCompliance: input.SyncCompliance }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
  };
};

const serializeAws_json1_1CreateAssociationRequest = (
  input: CreateAssociationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ApplyOnlyAtCronInterval !== undefined && { ApplyOnlyAtCronInterval: input.ApplyOnlyAtCronInterval }),
    ...(input.AssociationName !== undefined && { AssociationName: input.AssociationName }),
    ...(input.AutomationTargetParameterName !== undefined && {
      AutomationTargetParameterName: input.AutomationTargetParameterName,
    }),
    ...(input.ComplianceSeverity !== undefined && { ComplianceSeverity: input.ComplianceSeverity }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.OutputLocation !== undefined && {
      OutputLocation: serializeAws_json1_1InstanceAssociationOutputLocation(input.OutputLocation, context),
    }),
    ...(input.Parameters !== undefined && { Parameters: serializeAws_json1_1Parameters(input.Parameters, context) }),
    ...(input.ScheduleExpression !== undefined && { ScheduleExpression: input.ScheduleExpression }),
    ...(input.SyncCompliance !== undefined && { SyncCompliance: input.SyncCompliance }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
  };
};

const serializeAws_json1_1CreateDocumentRequest = (input: CreateDocumentRequest, context: __SerdeContext): any => {
  return {
    ...(input.Attachments !== undefined && {
      Attachments: serializeAws_json1_1AttachmentsSourceList(input.Attachments, context),
    }),
    ...(input.Content !== undefined && { Content: input.Content }),
    ...(input.DocumentFormat !== undefined && { DocumentFormat: input.DocumentFormat }),
    ...(input.DocumentType !== undefined && { DocumentType: input.DocumentType }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Requires !== undefined && {
      Requires: serializeAws_json1_1DocumentRequiresList(input.Requires, context),
    }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
    ...(input.TargetType !== undefined && { TargetType: input.TargetType }),
    ...(input.VersionName !== undefined && { VersionName: input.VersionName }),
  };
};

const serializeAws_json1_1CreateMaintenanceWindowRequest = (
  input: CreateMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AllowUnassociatedTargets !== undefined && { AllowUnassociatedTargets: input.AllowUnassociatedTargets }),
    ClientToken: input.ClientToken ?? generateIdempotencyToken(),
    ...(input.Cutoff !== undefined && { Cutoff: input.Cutoff }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.Duration !== undefined && { Duration: input.Duration }),
    ...(input.EndDate !== undefined && { EndDate: input.EndDate }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Schedule !== undefined && { Schedule: input.Schedule }),
    ...(input.ScheduleOffset !== undefined && { ScheduleOffset: input.ScheduleOffset }),
    ...(input.ScheduleTimezone !== undefined && { ScheduleTimezone: input.ScheduleTimezone }),
    ...(input.StartDate !== undefined && { StartDate: input.StartDate }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
  };
};

const serializeAws_json1_1CreateOpsItemRequest = (input: CreateOpsItemRequest, context: __SerdeContext): any => {
  return {
    ...(input.Category !== undefined && { Category: input.Category }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.Notifications !== undefined && {
      Notifications: serializeAws_json1_1OpsItemNotifications(input.Notifications, context),
    }),
    ...(input.OperationalData !== undefined && {
      OperationalData: serializeAws_json1_1OpsItemOperationalData(input.OperationalData, context),
    }),
    ...(input.Priority !== undefined && { Priority: input.Priority }),
    ...(input.RelatedOpsItems !== undefined && {
      RelatedOpsItems: serializeAws_json1_1RelatedOpsItems(input.RelatedOpsItems, context),
    }),
    ...(input.Severity !== undefined && { Severity: input.Severity }),
    ...(input.Source !== undefined && { Source: input.Source }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
    ...(input.Title !== undefined && { Title: input.Title }),
  };
};

const serializeAws_json1_1CreatePatchBaselineRequest = (
  input: CreatePatchBaselineRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ApprovalRules !== undefined && {
      ApprovalRules: serializeAws_json1_1PatchRuleGroup(input.ApprovalRules, context),
    }),
    ...(input.ApprovedPatches !== undefined && {
      ApprovedPatches: serializeAws_json1_1PatchIdList(input.ApprovedPatches, context),
    }),
    ...(input.ApprovedPatchesComplianceLevel !== undefined && {
      ApprovedPatchesComplianceLevel: input.ApprovedPatchesComplianceLevel,
    }),
    ...(input.ApprovedPatchesEnableNonSecurity !== undefined && {
      ApprovedPatchesEnableNonSecurity: input.ApprovedPatchesEnableNonSecurity,
    }),
    ClientToken: input.ClientToken ?? generateIdempotencyToken(),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.GlobalFilters !== undefined && {
      GlobalFilters: serializeAws_json1_1PatchFilterGroup(input.GlobalFilters, context),
    }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.OperatingSystem !== undefined && { OperatingSystem: input.OperatingSystem }),
    ...(input.RejectedPatches !== undefined && {
      RejectedPatches: serializeAws_json1_1PatchIdList(input.RejectedPatches, context),
    }),
    ...(input.RejectedPatchesAction !== undefined && { RejectedPatchesAction: input.RejectedPatchesAction }),
    ...(input.Sources !== undefined && { Sources: serializeAws_json1_1PatchSourceList(input.Sources, context) }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
  };
};

const serializeAws_json1_1CreateResourceDataSyncRequest = (
  input: CreateResourceDataSyncRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.S3Destination !== undefined && {
      S3Destination: serializeAws_json1_1ResourceDataSyncS3Destination(input.S3Destination, context),
    }),
    ...(input.SyncName !== undefined && { SyncName: input.SyncName }),
    ...(input.SyncSource !== undefined && {
      SyncSource: serializeAws_json1_1ResourceDataSyncSource(input.SyncSource, context),
    }),
    ...(input.SyncType !== undefined && { SyncType: input.SyncType }),
  };
};

const serializeAws_json1_1DeleteActivationRequest = (input: DeleteActivationRequest, context: __SerdeContext): any => {
  return {
    ...(input.ActivationId !== undefined && { ActivationId: input.ActivationId }),
  };
};

const serializeAws_json1_1DeleteAssociationRequest = (
  input: DeleteAssociationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationId !== undefined && { AssociationId: input.AssociationId }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1DeleteDocumentRequest = (input: DeleteDocumentRequest, context: __SerdeContext): any => {
  return {
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.Force !== undefined && { Force: input.Force }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.VersionName !== undefined && { VersionName: input.VersionName }),
  };
};

const serializeAws_json1_1DeleteInventoryRequest = (input: DeleteInventoryRequest, context: __SerdeContext): any => {
  return {
    ClientToken: input.ClientToken ?? generateIdempotencyToken(),
    ...(input.DryRun !== undefined && { DryRun: input.DryRun }),
    ...(input.SchemaDeleteOption !== undefined && { SchemaDeleteOption: input.SchemaDeleteOption }),
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
  };
};

const serializeAws_json1_1DeleteMaintenanceWindowRequest = (
  input: DeleteMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1DeleteParameterRequest = (input: DeleteParameterRequest, context: __SerdeContext): any => {
  return {
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1DeleteParametersRequest = (input: DeleteParametersRequest, context: __SerdeContext): any => {
  return {
    ...(input.Names !== undefined && { Names: serializeAws_json1_1ParameterNameList(input.Names, context) }),
  };
};

const serializeAws_json1_1DeletePatchBaselineRequest = (
  input: DeletePatchBaselineRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
  };
};

const serializeAws_json1_1DeleteResourceDataSyncRequest = (
  input: DeleteResourceDataSyncRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.SyncName !== undefined && { SyncName: input.SyncName }),
    ...(input.SyncType !== undefined && { SyncType: input.SyncType }),
  };
};

const serializeAws_json1_1DeregisterManagedInstanceRequest = (
  input: DeregisterManagedInstanceRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
  };
};

const serializeAws_json1_1DeregisterPatchBaselineForPatchGroupRequest = (
  input: DeregisterPatchBaselineForPatchGroupRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
    ...(input.PatchGroup !== undefined && { PatchGroup: input.PatchGroup }),
  };
};

const serializeAws_json1_1DeregisterTargetFromMaintenanceWindowRequest = (
  input: DeregisterTargetFromMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Safe !== undefined && { Safe: input.Safe }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
    ...(input.WindowTargetId !== undefined && { WindowTargetId: input.WindowTargetId }),
  };
};

const serializeAws_json1_1DeregisterTaskFromMaintenanceWindowRequest = (
  input: DeregisterTaskFromMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
    ...(input.WindowTaskId !== undefined && { WindowTaskId: input.WindowTaskId }),
  };
};

const serializeAws_json1_1DescribeActivationsFilter = (
  input: DescribeActivationsFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.FilterKey !== undefined && { FilterKey: input.FilterKey }),
    ...(input.FilterValues !== undefined && {
      FilterValues: serializeAws_json1_1StringList(input.FilterValues, context),
    }),
  };
};

const serializeAws_json1_1DescribeActivationsFilterList = (
  input: DescribeActivationsFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1DescribeActivationsFilter(entry, context));
};

const serializeAws_json1_1DescribeActivationsRequest = (
  input: DescribeActivationsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1DescribeActivationsFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeAssociationExecutionsRequest = (
  input: DescribeAssociationExecutionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationId !== undefined && { AssociationId: input.AssociationId }),
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1AssociationExecutionFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeAssociationExecutionTargetsRequest = (
  input: DescribeAssociationExecutionTargetsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationId !== undefined && { AssociationId: input.AssociationId }),
    ...(input.ExecutionId !== undefined && { ExecutionId: input.ExecutionId }),
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1AssociationExecutionTargetsFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeAssociationRequest = (
  input: DescribeAssociationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationId !== undefined && { AssociationId: input.AssociationId }),
    ...(input.AssociationVersion !== undefined && { AssociationVersion: input.AssociationVersion }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1DescribeAutomationExecutionsRequest = (
  input: DescribeAutomationExecutionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1AutomationExecutionFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeAutomationStepExecutionsRequest = (
  input: DescribeAutomationStepExecutionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AutomationExecutionId !== undefined && { AutomationExecutionId: input.AutomationExecutionId }),
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1StepExecutionFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ReverseOrder !== undefined && { ReverseOrder: input.ReverseOrder }),
  };
};

const serializeAws_json1_1DescribeAvailablePatchesRequest = (
  input: DescribeAvailablePatchesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1PatchOrchestratorFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeDocumentPermissionRequest = (
  input: DescribeDocumentPermissionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.PermissionType !== undefined && { PermissionType: input.PermissionType }),
  };
};

const serializeAws_json1_1DescribeDocumentRequest = (input: DescribeDocumentRequest, context: __SerdeContext): any => {
  return {
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.VersionName !== undefined && { VersionName: input.VersionName }),
  };
};

const serializeAws_json1_1DescribeEffectiveInstanceAssociationsRequest = (
  input: DescribeEffectiveInstanceAssociationsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeEffectivePatchesForPatchBaselineRequest = (
  input: DescribeEffectivePatchesForPatchBaselineRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeInstanceAssociationsStatusRequest = (
  input: DescribeInstanceAssociationsStatusRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeInstanceInformationRequest = (
  input: DescribeInstanceInformationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1InstanceInformationStringFilterList(input.Filters, context),
    }),
    ...(input.InstanceInformationFilterList !== undefined && {
      InstanceInformationFilterList: serializeAws_json1_1InstanceInformationFilterList(
        input.InstanceInformationFilterList,
        context
      ),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeInstancePatchesRequest = (
  input: DescribeInstancePatchesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1PatchOrchestratorFilterList(input.Filters, context),
    }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeInstancePatchStatesForPatchGroupRequest = (
  input: DescribeInstancePatchStatesForPatchGroupRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1InstancePatchStateFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.PatchGroup !== undefined && { PatchGroup: input.PatchGroup }),
  };
};

const serializeAws_json1_1DescribeInstancePatchStatesRequest = (
  input: DescribeInstancePatchStatesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InstanceIds !== undefined && {
      InstanceIds: serializeAws_json1_1InstanceIdList(input.InstanceIds, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeInventoryDeletionsRequest = (
  input: DescribeInventoryDeletionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.DeletionId !== undefined && { DeletionId: input.DeletionId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowExecutionsRequest = (
  input: DescribeMaintenanceWindowExecutionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1MaintenanceWindowFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsRequest = (
  input: DescribeMaintenanceWindowExecutionTaskInvocationsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1MaintenanceWindowFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.TaskId !== undefined && { TaskId: input.TaskId }),
    ...(input.WindowExecutionId !== undefined && { WindowExecutionId: input.WindowExecutionId }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowExecutionTasksRequest = (
  input: DescribeMaintenanceWindowExecutionTasksRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1MaintenanceWindowFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.WindowExecutionId !== undefined && { WindowExecutionId: input.WindowExecutionId }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowScheduleRequest = (
  input: DescribeMaintenanceWindowScheduleRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1PatchOrchestratorFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowsForTargetRequest = (
  input: DescribeMaintenanceWindowsForTargetRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowsRequest = (
  input: DescribeMaintenanceWindowsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1MaintenanceWindowFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowTargetsRequest = (
  input: DescribeMaintenanceWindowTargetsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1MaintenanceWindowFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1DescribeMaintenanceWindowTasksRequest = (
  input: DescribeMaintenanceWindowTasksRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1MaintenanceWindowFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1DescribeOpsItemsRequest = (input: DescribeOpsItemsRequest, context: __SerdeContext): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.OpsItemFilters !== undefined && {
      OpsItemFilters: serializeAws_json1_1OpsItemFilters(input.OpsItemFilters, context),
    }),
  };
};

const serializeAws_json1_1DescribeParametersRequest = (
  input: DescribeParametersRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1ParametersFilterList(input.Filters, context) }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ParameterFilters !== undefined && {
      ParameterFilters: serializeAws_json1_1ParameterStringFilterList(input.ParameterFilters, context),
    }),
  };
};

const serializeAws_json1_1DescribePatchBaselinesRequest = (
  input: DescribePatchBaselinesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1PatchOrchestratorFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribePatchGroupsRequest = (
  input: DescribePatchGroupsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1PatchOrchestratorFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1DescribePatchGroupStateRequest = (
  input: DescribePatchGroupStateRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.PatchGroup !== undefined && { PatchGroup: input.PatchGroup }),
  };
};

const serializeAws_json1_1DescribePatchPropertiesRequest = (
  input: DescribePatchPropertiesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.OperatingSystem !== undefined && { OperatingSystem: input.OperatingSystem }),
    ...(input.PatchSet !== undefined && { PatchSet: input.PatchSet }),
    ...(input.Property !== undefined && { Property: input.Property }),
  };
};

const serializeAws_json1_1DescribeSessionsRequest = (input: DescribeSessionsRequest, context: __SerdeContext): any => {
  return {
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1SessionFilterList(input.Filters, context) }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.State !== undefined && { State: input.State }),
  };
};

const serializeAws_json1_1DocumentFilter = (input: DocumentFilter, context: __SerdeContext): any => {
  return {
    ...(input.key !== undefined && { key: input.key }),
    ...(input.value !== undefined && { value: input.value }),
  };
};

const serializeAws_json1_1DocumentFilterList = (input: DocumentFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1DocumentFilter(entry, context));
};

const serializeAws_json1_1DocumentKeyValuesFilter = (input: DocumentKeyValuesFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1DocumentKeyValuesFilterValues(input.Values, context),
    }),
  };
};

const serializeAws_json1_1DocumentKeyValuesFilterList = (
  input: DocumentKeyValuesFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1DocumentKeyValuesFilter(entry, context));
};

const serializeAws_json1_1DocumentKeyValuesFilterValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1DocumentRequires = (input: DocumentRequires, context: __SerdeContext): any => {
  return {
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Version !== undefined && { Version: input.Version }),
  };
};

const serializeAws_json1_1DocumentRequiresList = (input: DocumentRequires[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1DocumentRequires(entry, context));
};

const serializeAws_json1_1GetAutomationExecutionRequest = (
  input: GetAutomationExecutionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AutomationExecutionId !== undefined && { AutomationExecutionId: input.AutomationExecutionId }),
  };
};

const serializeAws_json1_1GetCalendarStateRequest = (input: GetCalendarStateRequest, context: __SerdeContext): any => {
  return {
    ...(input.AtTime !== undefined && { AtTime: input.AtTime }),
    ...(input.CalendarNames !== undefined && {
      CalendarNames: serializeAws_json1_1CalendarNameOrARNList(input.CalendarNames, context),
    }),
  };
};

const serializeAws_json1_1GetCommandInvocationRequest = (
  input: GetCommandInvocationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.CommandId !== undefined && { CommandId: input.CommandId }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.PluginName !== undefined && { PluginName: input.PluginName }),
  };
};

const serializeAws_json1_1GetConnectionStatusRequest = (
  input: GetConnectionStatusRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Target !== undefined && { Target: input.Target }),
  };
};

const serializeAws_json1_1GetDefaultPatchBaselineRequest = (
  input: GetDefaultPatchBaselineRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.OperatingSystem !== undefined && { OperatingSystem: input.OperatingSystem }),
  };
};

const serializeAws_json1_1GetDeployablePatchSnapshotForInstanceRequest = (
  input: GetDeployablePatchSnapshotForInstanceRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.SnapshotId !== undefined && { SnapshotId: input.SnapshotId }),
  };
};

const serializeAws_json1_1GetDocumentRequest = (input: GetDocumentRequest, context: __SerdeContext): any => {
  return {
    ...(input.DocumentFormat !== undefined && { DocumentFormat: input.DocumentFormat }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.VersionName !== undefined && { VersionName: input.VersionName }),
  };
};

const serializeAws_json1_1GetInventoryRequest = (input: GetInventoryRequest, context: __SerdeContext): any => {
  return {
    ...(input.Aggregators !== undefined && {
      Aggregators: serializeAws_json1_1InventoryAggregatorList(input.Aggregators, context),
    }),
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1InventoryFilterList(input.Filters, context) }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ResultAttributes !== undefined && {
      ResultAttributes: serializeAws_json1_1ResultAttributeList(input.ResultAttributes, context),
    }),
  };
};

const serializeAws_json1_1GetInventorySchemaRequest = (
  input: GetInventorySchemaRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Aggregator !== undefined && { Aggregator: input.Aggregator }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.SubType !== undefined && { SubType: input.SubType }),
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
  };
};

const serializeAws_json1_1GetMaintenanceWindowExecutionRequest = (
  input: GetMaintenanceWindowExecutionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.WindowExecutionId !== undefined && { WindowExecutionId: input.WindowExecutionId }),
  };
};

const serializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationRequest = (
  input: GetMaintenanceWindowExecutionTaskInvocationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InvocationId !== undefined && { InvocationId: input.InvocationId }),
    ...(input.TaskId !== undefined && { TaskId: input.TaskId }),
    ...(input.WindowExecutionId !== undefined && { WindowExecutionId: input.WindowExecutionId }),
  };
};

const serializeAws_json1_1GetMaintenanceWindowExecutionTaskRequest = (
  input: GetMaintenanceWindowExecutionTaskRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.TaskId !== undefined && { TaskId: input.TaskId }),
    ...(input.WindowExecutionId !== undefined && { WindowExecutionId: input.WindowExecutionId }),
  };
};

const serializeAws_json1_1GetMaintenanceWindowRequest = (
  input: GetMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1GetMaintenanceWindowTaskRequest = (
  input: GetMaintenanceWindowTaskRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
    ...(input.WindowTaskId !== undefined && { WindowTaskId: input.WindowTaskId }),
  };
};

const serializeAws_json1_1GetOpsItemRequest = (input: GetOpsItemRequest, context: __SerdeContext): any => {
  return {
    ...(input.OpsItemId !== undefined && { OpsItemId: input.OpsItemId }),
  };
};

const serializeAws_json1_1GetOpsSummaryRequest = (input: GetOpsSummaryRequest, context: __SerdeContext): any => {
  return {
    ...(input.Aggregators !== undefined && {
      Aggregators: serializeAws_json1_1OpsAggregatorList(input.Aggregators, context),
    }),
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1OpsFilterList(input.Filters, context) }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ResultAttributes !== undefined && {
      ResultAttributes: serializeAws_json1_1OpsResultAttributeList(input.ResultAttributes, context),
    }),
    ...(input.SyncName !== undefined && { SyncName: input.SyncName }),
  };
};

const serializeAws_json1_1GetParameterHistoryRequest = (
  input: GetParameterHistoryRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.WithDecryption !== undefined && { WithDecryption: input.WithDecryption }),
  };
};

const serializeAws_json1_1GetParameterRequest = (input: GetParameterRequest, context: __SerdeContext): any => {
  return {
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.WithDecryption !== undefined && { WithDecryption: input.WithDecryption }),
  };
};

const serializeAws_json1_1GetParametersByPathRequest = (
  input: GetParametersByPathRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ParameterFilters !== undefined && {
      ParameterFilters: serializeAws_json1_1ParameterStringFilterList(input.ParameterFilters, context),
    }),
    ...(input.Path !== undefined && { Path: input.Path }),
    ...(input.Recursive !== undefined && { Recursive: input.Recursive }),
    ...(input.WithDecryption !== undefined && { WithDecryption: input.WithDecryption }),
  };
};

const serializeAws_json1_1GetParametersRequest = (input: GetParametersRequest, context: __SerdeContext): any => {
  return {
    ...(input.Names !== undefined && { Names: serializeAws_json1_1ParameterNameList(input.Names, context) }),
    ...(input.WithDecryption !== undefined && { WithDecryption: input.WithDecryption }),
  };
};

const serializeAws_json1_1GetPatchBaselineForPatchGroupRequest = (
  input: GetPatchBaselineForPatchGroupRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.OperatingSystem !== undefined && { OperatingSystem: input.OperatingSystem }),
    ...(input.PatchGroup !== undefined && { PatchGroup: input.PatchGroup }),
  };
};

const serializeAws_json1_1GetPatchBaselineRequest = (input: GetPatchBaselineRequest, context: __SerdeContext): any => {
  return {
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
  };
};

const serializeAws_json1_1GetServiceSettingRequest = (
  input: GetServiceSettingRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.SettingId !== undefined && { SettingId: input.SettingId }),
  };
};

const serializeAws_json1_1InstanceAssociationOutputLocation = (
  input: InstanceAssociationOutputLocation,
  context: __SerdeContext
): any => {
  return {
    ...(input.S3Location !== undefined && {
      S3Location: serializeAws_json1_1S3OutputLocation(input.S3Location, context),
    }),
  };
};

const serializeAws_json1_1InstanceIdList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1InstanceInformationFilter = (
  input: InstanceInformationFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.key !== undefined && { key: input.key }),
    ...(input.valueSet !== undefined && {
      valueSet: serializeAws_json1_1InstanceInformationFilterValueSet(input.valueSet, context),
    }),
  };
};

const serializeAws_json1_1InstanceInformationFilterList = (
  input: InstanceInformationFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1InstanceInformationFilter(entry, context));
};

const serializeAws_json1_1InstanceInformationFilterValueSet = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1InstanceInformationStringFilter = (
  input: InstanceInformationStringFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1InstanceInformationFilterValueSet(input.Values, context),
    }),
  };
};

const serializeAws_json1_1InstanceInformationStringFilterList = (
  input: InstanceInformationStringFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1InstanceInformationStringFilter(entry, context));
};

const serializeAws_json1_1InstancePatchStateFilter = (
  input: InstancePatchStateFilter,
  context: __SerdeContext
): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1InstancePatchStateFilterValues(input.Values, context),
    }),
  };
};

const serializeAws_json1_1InstancePatchStateFilterList = (
  input: InstancePatchStateFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1InstancePatchStateFilter(entry, context));
};

const serializeAws_json1_1InstancePatchStateFilterValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1InventoryAggregator = (input: InventoryAggregator, context: __SerdeContext): any => {
  return {
    ...(input.Aggregators !== undefined && {
      Aggregators: serializeAws_json1_1InventoryAggregatorList(input.Aggregators, context),
    }),
    ...(input.Expression !== undefined && { Expression: input.Expression }),
    ...(input.Groups !== undefined && { Groups: serializeAws_json1_1InventoryGroupList(input.Groups, context) }),
  };
};

const serializeAws_json1_1InventoryAggregatorList = (input: InventoryAggregator[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1InventoryAggregator(entry, context));
};

const serializeAws_json1_1InventoryFilter = (input: InventoryFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1InventoryFilterValueList(input.Values, context) }),
  };
};

const serializeAws_json1_1InventoryFilterList = (input: InventoryFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1InventoryFilter(entry, context));
};

const serializeAws_json1_1InventoryFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1InventoryGroup = (input: InventoryGroup, context: __SerdeContext): any => {
  return {
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1InventoryFilterList(input.Filters, context) }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1InventoryGroupList = (input: InventoryGroup[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1InventoryGroup(entry, context));
};

const serializeAws_json1_1InventoryItem = (input: InventoryItem, context: __SerdeContext): any => {
  return {
    ...(input.CaptureTime !== undefined && { CaptureTime: input.CaptureTime }),
    ...(input.Content !== undefined && { Content: serializeAws_json1_1InventoryItemEntryList(input.Content, context) }),
    ...(input.ContentHash !== undefined && { ContentHash: input.ContentHash }),
    ...(input.Context !== undefined && {
      Context: serializeAws_json1_1InventoryItemContentContext(input.Context, context),
    }),
    ...(input.SchemaVersion !== undefined && { SchemaVersion: input.SchemaVersion }),
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
  };
};

const serializeAws_json1_1InventoryItemContentContext = (
  input: { [key: string]: string },
  context: __SerdeContext
): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const serializeAws_json1_1InventoryItemEntry = (input: { [key: string]: string }, context: __SerdeContext): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const serializeAws_json1_1InventoryItemEntryList = (
  input: { [key: string]: string }[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1InventoryItemEntry(entry, context));
};

const serializeAws_json1_1InventoryItemList = (input: InventoryItem[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1InventoryItem(entry, context));
};

const serializeAws_json1_1KeyList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1LabelParameterVersionRequest = (
  input: LabelParameterVersionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Labels !== undefined && { Labels: serializeAws_json1_1ParameterLabelList(input.Labels, context) }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.ParameterVersion !== undefined && { ParameterVersion: input.ParameterVersion }),
  };
};

const serializeAws_json1_1ListAssociationsRequest = (input: ListAssociationsRequest, context: __SerdeContext): any => {
  return {
    ...(input.AssociationFilterList !== undefined && {
      AssociationFilterList: serializeAws_json1_1AssociationFilterList(input.AssociationFilterList, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListAssociationVersionsRequest = (
  input: ListAssociationVersionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationId !== undefined && { AssociationId: input.AssociationId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListCommandInvocationsRequest = (
  input: ListCommandInvocationsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.CommandId !== undefined && { CommandId: input.CommandId }),
    ...(input.Details !== undefined && { Details: input.Details }),
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1CommandFilterList(input.Filters, context) }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListCommandsRequest = (input: ListCommandsRequest, context: __SerdeContext): any => {
  return {
    ...(input.CommandId !== undefined && { CommandId: input.CommandId }),
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1CommandFilterList(input.Filters, context) }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListComplianceItemsRequest = (
  input: ListComplianceItemsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1ComplianceStringFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.ResourceIds !== undefined && {
      ResourceIds: serializeAws_json1_1ComplianceResourceIdList(input.ResourceIds, context),
    }),
    ...(input.ResourceTypes !== undefined && {
      ResourceTypes: serializeAws_json1_1ComplianceResourceTypeList(input.ResourceTypes, context),
    }),
  };
};

const serializeAws_json1_1ListComplianceSummariesRequest = (
  input: ListComplianceSummariesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1ComplianceStringFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListDocumentsRequest = (input: ListDocumentsRequest, context: __SerdeContext): any => {
  return {
    ...(input.DocumentFilterList !== undefined && {
      DocumentFilterList: serializeAws_json1_1DocumentFilterList(input.DocumentFilterList, context),
    }),
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1DocumentKeyValuesFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListDocumentVersionsRequest = (
  input: ListDocumentVersionsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListInventoryEntriesRequest = (
  input: ListInventoryEntriesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1InventoryFilterList(input.Filters, context) }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
  };
};

const serializeAws_json1_1ListResourceComplianceSummariesRequest = (
  input: ListResourceComplianceSummariesRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Filters !== undefined && {
      Filters: serializeAws_json1_1ComplianceStringFilterList(input.Filters, context),
    }),
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
  };
};

const serializeAws_json1_1ListResourceDataSyncRequest = (
  input: ListResourceDataSyncRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.MaxResults !== undefined && { MaxResults: input.MaxResults }),
    ...(input.NextToken !== undefined && { NextToken: input.NextToken }),
    ...(input.SyncType !== undefined && { SyncType: input.SyncType }),
  };
};

const serializeAws_json1_1ListTagsForResourceRequest = (
  input: ListTagsForResourceRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ResourceId !== undefined && { ResourceId: input.ResourceId }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
  };
};

const serializeAws_json1_1LoggingInfo = (input: LoggingInfo, context: __SerdeContext): any => {
  return {
    ...(input.S3BucketName !== undefined && { S3BucketName: input.S3BucketName }),
    ...(input.S3KeyPrefix !== undefined && { S3KeyPrefix: input.S3KeyPrefix }),
    ...(input.S3Region !== undefined && { S3Region: input.S3Region }),
  };
};

const serializeAws_json1_1MaintenanceWindowAutomationParameters = (
  input: MaintenanceWindowAutomationParameters,
  context: __SerdeContext
): any => {
  return {
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.Parameters !== undefined && {
      Parameters: serializeAws_json1_1AutomationParameterMap(input.Parameters, context),
    }),
  };
};

const serializeAws_json1_1MaintenanceWindowFilter = (input: MaintenanceWindowFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1MaintenanceWindowFilterValues(input.Values, context),
    }),
  };
};

const serializeAws_json1_1MaintenanceWindowFilterList = (
  input: MaintenanceWindowFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1MaintenanceWindowFilter(entry, context));
};

const serializeAws_json1_1MaintenanceWindowFilterValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1MaintenanceWindowLambdaParameters = (
  input: MaintenanceWindowLambdaParameters,
  context: __SerdeContext
): any => {
  return {
    ...(input.ClientContext !== undefined && { ClientContext: input.ClientContext }),
    ...(input.Payload !== undefined && { Payload: context.base64Encoder(input.Payload) }),
    ...(input.Qualifier !== undefined && { Qualifier: input.Qualifier }),
  };
};

const serializeAws_json1_1MaintenanceWindowRunCommandParameters = (
  input: MaintenanceWindowRunCommandParameters,
  context: __SerdeContext
): any => {
  return {
    ...(input.CloudWatchOutputConfig !== undefined && {
      CloudWatchOutputConfig: serializeAws_json1_1CloudWatchOutputConfig(input.CloudWatchOutputConfig, context),
    }),
    ...(input.Comment !== undefined && { Comment: input.Comment }),
    ...(input.DocumentHash !== undefined && { DocumentHash: input.DocumentHash }),
    ...(input.DocumentHashType !== undefined && { DocumentHashType: input.DocumentHashType }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.NotificationConfig !== undefined && {
      NotificationConfig: serializeAws_json1_1NotificationConfig(input.NotificationConfig, context),
    }),
    ...(input.OutputS3BucketName !== undefined && { OutputS3BucketName: input.OutputS3BucketName }),
    ...(input.OutputS3KeyPrefix !== undefined && { OutputS3KeyPrefix: input.OutputS3KeyPrefix }),
    ...(input.Parameters !== undefined && { Parameters: serializeAws_json1_1Parameters(input.Parameters, context) }),
    ...(input.ServiceRoleArn !== undefined && { ServiceRoleArn: input.ServiceRoleArn }),
    ...(input.TimeoutSeconds !== undefined && { TimeoutSeconds: input.TimeoutSeconds }),
  };
};

const serializeAws_json1_1MaintenanceWindowStepFunctionsParameters = (
  input: MaintenanceWindowStepFunctionsParameters,
  context: __SerdeContext
): any => {
  return {
    ...(input.Input !== undefined && { Input: input.Input }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1MaintenanceWindowTaskInvocationParameters = (
  input: MaintenanceWindowTaskInvocationParameters,
  context: __SerdeContext
): any => {
  return {
    ...(input.Automation !== undefined && {
      Automation: serializeAws_json1_1MaintenanceWindowAutomationParameters(input.Automation, context),
    }),
    ...(input.Lambda !== undefined && {
      Lambda: serializeAws_json1_1MaintenanceWindowLambdaParameters(input.Lambda, context),
    }),
    ...(input.RunCommand !== undefined && {
      RunCommand: serializeAws_json1_1MaintenanceWindowRunCommandParameters(input.RunCommand, context),
    }),
    ...(input.StepFunctions !== undefined && {
      StepFunctions: serializeAws_json1_1MaintenanceWindowStepFunctionsParameters(input.StepFunctions, context),
    }),
  };
};

const serializeAws_json1_1MaintenanceWindowTaskParameters = (
  input: { [key: string]: MaintenanceWindowTaskParameterValueExpression },
  context: __SerdeContext
): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: MaintenanceWindowTaskParameterValueExpression }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: serializeAws_json1_1MaintenanceWindowTaskParameterValueExpression(value, context),
    }),
    {}
  );
};

const serializeAws_json1_1MaintenanceWindowTaskParameterValueExpression = (
  input: MaintenanceWindowTaskParameterValueExpression,
  context: __SerdeContext
): any => {
  return {
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1MaintenanceWindowTaskParameterValueList(input.Values, context),
    }),
  };
};

const serializeAws_json1_1MaintenanceWindowTaskParameterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ModifyDocumentPermissionRequest = (
  input: ModifyDocumentPermissionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AccountIdsToAdd !== undefined && {
      AccountIdsToAdd: serializeAws_json1_1AccountIdList(input.AccountIdsToAdd, context),
    }),
    ...(input.AccountIdsToRemove !== undefined && {
      AccountIdsToRemove: serializeAws_json1_1AccountIdList(input.AccountIdsToRemove, context),
    }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.PermissionType !== undefined && { PermissionType: input.PermissionType }),
    ...(input.SharedDocumentVersion !== undefined && { SharedDocumentVersion: input.SharedDocumentVersion }),
  };
};

const serializeAws_json1_1NotificationConfig = (input: NotificationConfig, context: __SerdeContext): any => {
  return {
    ...(input.NotificationArn !== undefined && { NotificationArn: input.NotificationArn }),
    ...(input.NotificationEvents !== undefined && {
      NotificationEvents: serializeAws_json1_1NotificationEventList(input.NotificationEvents, context),
    }),
    ...(input.NotificationType !== undefined && { NotificationType: input.NotificationType }),
  };
};

const serializeAws_json1_1NotificationEventList = (
  input: (NotificationEvent | string)[],
  context: __SerdeContext
): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1OpsAggregator = (input: OpsAggregator, context: __SerdeContext): any => {
  return {
    ...(input.AggregatorType !== undefined && { AggregatorType: input.AggregatorType }),
    ...(input.Aggregators !== undefined && {
      Aggregators: serializeAws_json1_1OpsAggregatorList(input.Aggregators, context),
    }),
    ...(input.AttributeName !== undefined && { AttributeName: input.AttributeName }),
    ...(input.Filters !== undefined && { Filters: serializeAws_json1_1OpsFilterList(input.Filters, context) }),
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1OpsAggregatorValueMap(input.Values, context) }),
  };
};

const serializeAws_json1_1OpsAggregatorList = (input: OpsAggregator[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1OpsAggregator(entry, context));
};

const serializeAws_json1_1OpsAggregatorValueMap = (input: { [key: string]: string }, context: __SerdeContext): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const serializeAws_json1_1OpsFilter = (input: OpsFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1OpsFilterValueList(input.Values, context) }),
  };
};

const serializeAws_json1_1OpsFilterList = (input: OpsFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1OpsFilter(entry, context));
};

const serializeAws_json1_1OpsFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1OpsItemDataValue = (input: OpsItemDataValue, context: __SerdeContext): any => {
  return {
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Value !== undefined && { Value: input.Value }),
  };
};

const serializeAws_json1_1OpsItemFilter = (input: OpsItemFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Operator !== undefined && { Operator: input.Operator }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1OpsItemFilterValues(input.Values, context) }),
  };
};

const serializeAws_json1_1OpsItemFilters = (input: OpsItemFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1OpsItemFilter(entry, context));
};

const serializeAws_json1_1OpsItemFilterValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1OpsItemNotification = (input: OpsItemNotification, context: __SerdeContext): any => {
  return {
    ...(input.Arn !== undefined && { Arn: input.Arn }),
  };
};

const serializeAws_json1_1OpsItemNotifications = (input: OpsItemNotification[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1OpsItemNotification(entry, context));
};

const serializeAws_json1_1OpsItemOperationalData = (
  input: { [key: string]: OpsItemDataValue },
  context: __SerdeContext
): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: OpsItemDataValue }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: serializeAws_json1_1OpsItemDataValue(value, context),
    }),
    {}
  );
};

const serializeAws_json1_1OpsItemOpsDataKeysList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1OpsResultAttribute = (input: OpsResultAttribute, context: __SerdeContext): any => {
  return {
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
  };
};

const serializeAws_json1_1OpsResultAttributeList = (input: OpsResultAttribute[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1OpsResultAttribute(entry, context));
};

const serializeAws_json1_1ParameterLabelList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ParameterNameList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1Parameters = (input: { [key: string]: string[] }, context: __SerdeContext): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: serializeAws_json1_1ParameterValueList(value, context),
    }),
    {}
  );
};

const serializeAws_json1_1ParametersFilter = (input: ParametersFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1ParametersFilterValueList(input.Values, context) }),
  };
};

const serializeAws_json1_1ParametersFilterList = (input: ParametersFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1ParametersFilter(entry, context));
};

const serializeAws_json1_1ParametersFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ParameterStringFilter = (input: ParameterStringFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Option !== undefined && { Option: input.Option }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1ParameterStringFilterValueList(input.Values, context),
    }),
  };
};

const serializeAws_json1_1ParameterStringFilterList = (
  input: ParameterStringFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1ParameterStringFilter(entry, context));
};

const serializeAws_json1_1ParameterStringFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ParameterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1PatchFilter = (input: PatchFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1PatchFilterValueList(input.Values, context) }),
  };
};

const serializeAws_json1_1PatchFilterGroup = (input: PatchFilterGroup, context: __SerdeContext): any => {
  return {
    ...(input.PatchFilters !== undefined && {
      PatchFilters: serializeAws_json1_1PatchFilterList(input.PatchFilters, context),
    }),
  };
};

const serializeAws_json1_1PatchFilterList = (input: PatchFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1PatchFilter(entry, context));
};

const serializeAws_json1_1PatchFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1PatchIdList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1PatchOrchestratorFilter = (input: PatchOrchestratorFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1PatchOrchestratorFilterValues(input.Values, context),
    }),
  };
};

const serializeAws_json1_1PatchOrchestratorFilterList = (
  input: PatchOrchestratorFilter[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1PatchOrchestratorFilter(entry, context));
};

const serializeAws_json1_1PatchOrchestratorFilterValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1PatchRule = (input: PatchRule, context: __SerdeContext): any => {
  return {
    ...(input.ApproveAfterDays !== undefined && { ApproveAfterDays: input.ApproveAfterDays }),
    ...(input.ApproveUntilDate !== undefined && { ApproveUntilDate: input.ApproveUntilDate }),
    ...(input.ComplianceLevel !== undefined && { ComplianceLevel: input.ComplianceLevel }),
    ...(input.EnableNonSecurity !== undefined && { EnableNonSecurity: input.EnableNonSecurity }),
    ...(input.PatchFilterGroup !== undefined && {
      PatchFilterGroup: serializeAws_json1_1PatchFilterGroup(input.PatchFilterGroup, context),
    }),
  };
};

const serializeAws_json1_1PatchRuleGroup = (input: PatchRuleGroup, context: __SerdeContext): any => {
  return {
    ...(input.PatchRules !== undefined && { PatchRules: serializeAws_json1_1PatchRuleList(input.PatchRules, context) }),
  };
};

const serializeAws_json1_1PatchRuleList = (input: PatchRule[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1PatchRule(entry, context));
};

const serializeAws_json1_1PatchSource = (input: PatchSource, context: __SerdeContext): any => {
  return {
    ...(input.Configuration !== undefined && { Configuration: input.Configuration }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Products !== undefined && {
      Products: serializeAws_json1_1PatchSourceProductList(input.Products, context),
    }),
  };
};

const serializeAws_json1_1PatchSourceList = (input: PatchSource[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1PatchSource(entry, context));
};

const serializeAws_json1_1PatchSourceProductList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1PutComplianceItemsRequest = (
  input: PutComplianceItemsRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ComplianceType !== undefined && { ComplianceType: input.ComplianceType }),
    ...(input.ExecutionSummary !== undefined && {
      ExecutionSummary: serializeAws_json1_1ComplianceExecutionSummary(input.ExecutionSummary, context),
    }),
    ...(input.ItemContentHash !== undefined && { ItemContentHash: input.ItemContentHash }),
    ...(input.Items !== undefined && { Items: serializeAws_json1_1ComplianceItemEntryList(input.Items, context) }),
    ...(input.ResourceId !== undefined && { ResourceId: input.ResourceId }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
    ...(input.UploadType !== undefined && { UploadType: input.UploadType }),
  };
};

const serializeAws_json1_1PutInventoryRequest = (input: PutInventoryRequest, context: __SerdeContext): any => {
  return {
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.Items !== undefined && { Items: serializeAws_json1_1InventoryItemList(input.Items, context) }),
  };
};

const serializeAws_json1_1PutParameterRequest = (input: PutParameterRequest, context: __SerdeContext): any => {
  return {
    ...(input.AllowedPattern !== undefined && { AllowedPattern: input.AllowedPattern }),
    ...(input.DataType !== undefined && { DataType: input.DataType }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.KeyId !== undefined && { KeyId: input.KeyId }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Overwrite !== undefined && { Overwrite: input.Overwrite }),
    ...(input.Policies !== undefined && { Policies: input.Policies }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
    ...(input.Tier !== undefined && { Tier: input.Tier }),
    ...(input.Type !== undefined && { Type: input.Type }),
    ...(input.Value !== undefined && { Value: input.Value }),
  };
};

const serializeAws_json1_1Regions = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1RegisterDefaultPatchBaselineRequest = (
  input: RegisterDefaultPatchBaselineRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
  };
};

const serializeAws_json1_1RegisterPatchBaselineForPatchGroupRequest = (
  input: RegisterPatchBaselineForPatchGroupRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
    ...(input.PatchGroup !== undefined && { PatchGroup: input.PatchGroup }),
  };
};

const serializeAws_json1_1RegisterTargetWithMaintenanceWindowRequest = (
  input: RegisterTargetWithMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ClientToken: input.ClientToken ?? generateIdempotencyToken(),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.OwnerInformation !== undefined && { OwnerInformation: input.OwnerInformation }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1RegisterTaskWithMaintenanceWindowRequest = (
  input: RegisterTaskWithMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ClientToken: input.ClientToken ?? generateIdempotencyToken(),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.LoggingInfo !== undefined && {
      LoggingInfo: serializeAws_json1_1LoggingInfo(input.LoggingInfo, context),
    }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Priority !== undefined && { Priority: input.Priority }),
    ...(input.ServiceRoleArn !== undefined && { ServiceRoleArn: input.ServiceRoleArn }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
    ...(input.TaskArn !== undefined && { TaskArn: input.TaskArn }),
    ...(input.TaskInvocationParameters !== undefined && {
      TaskInvocationParameters: serializeAws_json1_1MaintenanceWindowTaskInvocationParameters(
        input.TaskInvocationParameters,
        context
      ),
    }),
    ...(input.TaskParameters !== undefined && {
      TaskParameters: serializeAws_json1_1MaintenanceWindowTaskParameters(input.TaskParameters, context),
    }),
    ...(input.TaskType !== undefined && { TaskType: input.TaskType }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1RelatedOpsItem = (input: RelatedOpsItem, context: __SerdeContext): any => {
  return {
    ...(input.OpsItemId !== undefined && { OpsItemId: input.OpsItemId }),
  };
};

const serializeAws_json1_1RelatedOpsItems = (input: RelatedOpsItem[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1RelatedOpsItem(entry, context));
};

const serializeAws_json1_1RemoveTagsFromResourceRequest = (
  input: RemoveTagsFromResourceRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ResourceId !== undefined && { ResourceId: input.ResourceId }),
    ...(input.ResourceType !== undefined && { ResourceType: input.ResourceType }),
    ...(input.TagKeys !== undefined && { TagKeys: serializeAws_json1_1KeyList(input.TagKeys, context) }),
  };
};

const serializeAws_json1_1ResetServiceSettingRequest = (
  input: ResetServiceSettingRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.SettingId !== undefined && { SettingId: input.SettingId }),
  };
};

const serializeAws_json1_1ResourceDataSyncAwsOrganizationsSource = (
  input: ResourceDataSyncAwsOrganizationsSource,
  context: __SerdeContext
): any => {
  return {
    ...(input.OrganizationSourceType !== undefined && { OrganizationSourceType: input.OrganizationSourceType }),
    ...(input.OrganizationalUnits !== undefined && {
      OrganizationalUnits: serializeAws_json1_1ResourceDataSyncOrganizationalUnitList(
        input.OrganizationalUnits,
        context
      ),
    }),
  };
};

const serializeAws_json1_1ResourceDataSyncDestinationDataSharing = (
  input: ResourceDataSyncDestinationDataSharing,
  context: __SerdeContext
): any => {
  return {
    ...(input.DestinationDataSharingType !== undefined && {
      DestinationDataSharingType: input.DestinationDataSharingType,
    }),
  };
};

const serializeAws_json1_1ResourceDataSyncOrganizationalUnit = (
  input: ResourceDataSyncOrganizationalUnit,
  context: __SerdeContext
): any => {
  return {
    ...(input.OrganizationalUnitId !== undefined && { OrganizationalUnitId: input.OrganizationalUnitId }),
  };
};

const serializeAws_json1_1ResourceDataSyncOrganizationalUnitList = (
  input: ResourceDataSyncOrganizationalUnit[],
  context: __SerdeContext
): any => {
  return input.map((entry) => serializeAws_json1_1ResourceDataSyncOrganizationalUnit(entry, context));
};

const serializeAws_json1_1ResourceDataSyncS3Destination = (
  input: ResourceDataSyncS3Destination,
  context: __SerdeContext
): any => {
  return {
    ...(input.AWSKMSKeyARN !== undefined && { AWSKMSKeyARN: input.AWSKMSKeyARN }),
    ...(input.BucketName !== undefined && { BucketName: input.BucketName }),
    ...(input.DestinationDataSharing !== undefined && {
      DestinationDataSharing: serializeAws_json1_1ResourceDataSyncDestinationDataSharing(
        input.DestinationDataSharing,
        context
      ),
    }),
    ...(input.Prefix !== undefined && { Prefix: input.Prefix }),
    ...(input.Region !== undefined && { Region: input.Region }),
    ...(input.SyncFormat !== undefined && { SyncFormat: input.SyncFormat }),
  };
};

const serializeAws_json1_1ResourceDataSyncSource = (input: ResourceDataSyncSource, context: __SerdeContext): any => {
  return {
    ...(input.AwsOrganizationsSource !== undefined && {
      AwsOrganizationsSource: serializeAws_json1_1ResourceDataSyncAwsOrganizationsSource(
        input.AwsOrganizationsSource,
        context
      ),
    }),
    ...(input.IncludeFutureRegions !== undefined && { IncludeFutureRegions: input.IncludeFutureRegions }),
    ...(input.SourceRegions !== undefined && {
      SourceRegions: serializeAws_json1_1ResourceDataSyncSourceRegionList(input.SourceRegions, context),
    }),
    ...(input.SourceType !== undefined && { SourceType: input.SourceType }),
  };
};

const serializeAws_json1_1ResourceDataSyncSourceRegionList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1ResultAttribute = (input: ResultAttribute, context: __SerdeContext): any => {
  return {
    ...(input.TypeName !== undefined && { TypeName: input.TypeName }),
  };
};

const serializeAws_json1_1ResultAttributeList = (input: ResultAttribute[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1ResultAttribute(entry, context));
};

const serializeAws_json1_1ResumeSessionRequest = (input: ResumeSessionRequest, context: __SerdeContext): any => {
  return {
    ...(input.SessionId !== undefined && { SessionId: input.SessionId }),
  };
};

const serializeAws_json1_1S3OutputLocation = (input: S3OutputLocation, context: __SerdeContext): any => {
  return {
    ...(input.OutputS3BucketName !== undefined && { OutputS3BucketName: input.OutputS3BucketName }),
    ...(input.OutputS3KeyPrefix !== undefined && { OutputS3KeyPrefix: input.OutputS3KeyPrefix }),
    ...(input.OutputS3Region !== undefined && { OutputS3Region: input.OutputS3Region }),
  };
};

const serializeAws_json1_1SendAutomationSignalRequest = (
  input: SendAutomationSignalRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AutomationExecutionId !== undefined && { AutomationExecutionId: input.AutomationExecutionId }),
    ...(input.Payload !== undefined && { Payload: serializeAws_json1_1AutomationParameterMap(input.Payload, context) }),
    ...(input.SignalType !== undefined && { SignalType: input.SignalType }),
  };
};

const serializeAws_json1_1SendCommandRequest = (input: SendCommandRequest, context: __SerdeContext): any => {
  return {
    ...(input.CloudWatchOutputConfig !== undefined && {
      CloudWatchOutputConfig: serializeAws_json1_1CloudWatchOutputConfig(input.CloudWatchOutputConfig, context),
    }),
    ...(input.Comment !== undefined && { Comment: input.Comment }),
    ...(input.DocumentHash !== undefined && { DocumentHash: input.DocumentHash }),
    ...(input.DocumentHashType !== undefined && { DocumentHashType: input.DocumentHashType }),
    ...(input.DocumentName !== undefined && { DocumentName: input.DocumentName }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.InstanceIds !== undefined && {
      InstanceIds: serializeAws_json1_1InstanceIdList(input.InstanceIds, context),
    }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.NotificationConfig !== undefined && {
      NotificationConfig: serializeAws_json1_1NotificationConfig(input.NotificationConfig, context),
    }),
    ...(input.OutputS3BucketName !== undefined && { OutputS3BucketName: input.OutputS3BucketName }),
    ...(input.OutputS3KeyPrefix !== undefined && { OutputS3KeyPrefix: input.OutputS3KeyPrefix }),
    ...(input.OutputS3Region !== undefined && { OutputS3Region: input.OutputS3Region }),
    ...(input.Parameters !== undefined && { Parameters: serializeAws_json1_1Parameters(input.Parameters, context) }),
    ...(input.ServiceRoleArn !== undefined && { ServiceRoleArn: input.ServiceRoleArn }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
    ...(input.TimeoutSeconds !== undefined && { TimeoutSeconds: input.TimeoutSeconds }),
  };
};

const serializeAws_json1_1SessionFilter = (input: SessionFilter, context: __SerdeContext): any => {
  return {
    ...(input.key !== undefined && { key: input.key }),
    ...(input.value !== undefined && { value: input.value }),
  };
};

const serializeAws_json1_1SessionFilterList = (input: SessionFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1SessionFilter(entry, context));
};

const serializeAws_json1_1SessionManagerParameters = (
  input: { [key: string]: string[] },
  context: __SerdeContext
): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: serializeAws_json1_1SessionManagerParameterValueList(value, context),
    }),
    {}
  );
};

const serializeAws_json1_1SessionManagerParameterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1StartAssociationsOnceRequest = (
  input: StartAssociationsOnceRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationIds !== undefined && {
      AssociationIds: serializeAws_json1_1AssociationIdList(input.AssociationIds, context),
    }),
  };
};

const serializeAws_json1_1StartAutomationExecutionRequest = (
  input: StartAutomationExecutionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ClientToken !== undefined && { ClientToken: input.ClientToken }),
    ...(input.DocumentName !== undefined && { DocumentName: input.DocumentName }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.Mode !== undefined && { Mode: input.Mode }),
    ...(input.Parameters !== undefined && {
      Parameters: serializeAws_json1_1AutomationParameterMap(input.Parameters, context),
    }),
    ...(input.Tags !== undefined && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
    ...(input.TargetLocations !== undefined && {
      TargetLocations: serializeAws_json1_1TargetLocations(input.TargetLocations, context),
    }),
    ...(input.TargetMaps !== undefined && { TargetMaps: serializeAws_json1_1TargetMaps(input.TargetMaps, context) }),
    ...(input.TargetParameterName !== undefined && { TargetParameterName: input.TargetParameterName }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
  };
};

const serializeAws_json1_1StartSessionRequest = (input: StartSessionRequest, context: __SerdeContext): any => {
  return {
    ...(input.DocumentName !== undefined && { DocumentName: input.DocumentName }),
    ...(input.Parameters !== undefined && {
      Parameters: serializeAws_json1_1SessionManagerParameters(input.Parameters, context),
    }),
    ...(input.Target !== undefined && { Target: input.Target }),
  };
};

const serializeAws_json1_1StepExecutionFilter = (input: StepExecutionFilter, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && {
      Values: serializeAws_json1_1StepExecutionFilterValueList(input.Values, context),
    }),
  };
};

const serializeAws_json1_1StepExecutionFilterList = (input: StepExecutionFilter[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1StepExecutionFilter(entry, context));
};

const serializeAws_json1_1StepExecutionFilterValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1StopAutomationExecutionRequest = (
  input: StopAutomationExecutionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AutomationExecutionId !== undefined && { AutomationExecutionId: input.AutomationExecutionId }),
    ...(input.Type !== undefined && { Type: input.Type }),
  };
};

const serializeAws_json1_1StringList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1Tag = (input: Tag, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Value !== undefined && { Value: input.Value }),
  };
};

const serializeAws_json1_1TagList = (input: Tag[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1Tag(entry, context));
};

const serializeAws_json1_1Target = (input: Target, context: __SerdeContext): any => {
  return {
    ...(input.Key !== undefined && { Key: input.Key }),
    ...(input.Values !== undefined && { Values: serializeAws_json1_1TargetValues(input.Values, context) }),
  };
};

const serializeAws_json1_1TargetLocation = (input: TargetLocation, context: __SerdeContext): any => {
  return {
    ...(input.Accounts !== undefined && { Accounts: serializeAws_json1_1Accounts(input.Accounts, context) }),
    ...(input.ExecutionRoleName !== undefined && { ExecutionRoleName: input.ExecutionRoleName }),
    ...(input.Regions !== undefined && { Regions: serializeAws_json1_1Regions(input.Regions, context) }),
    ...(input.TargetLocationMaxConcurrency !== undefined && {
      TargetLocationMaxConcurrency: input.TargetLocationMaxConcurrency,
    }),
    ...(input.TargetLocationMaxErrors !== undefined && { TargetLocationMaxErrors: input.TargetLocationMaxErrors }),
  };
};

const serializeAws_json1_1TargetLocations = (input: TargetLocation[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1TargetLocation(entry, context));
};

const serializeAws_json1_1TargetMap = (input: { [key: string]: string[] }, context: __SerdeContext): any => {
  return Object.entries(input).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: serializeAws_json1_1TargetMapValueList(value, context),
    }),
    {}
  );
};

const serializeAws_json1_1TargetMaps = (input: { [key: string]: string[] }[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1TargetMap(entry, context));
};

const serializeAws_json1_1TargetMapValueList = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1Targets = (input: Target[], context: __SerdeContext): any => {
  return input.map((entry) => serializeAws_json1_1Target(entry, context));
};

const serializeAws_json1_1TargetValues = (input: string[], context: __SerdeContext): any => {
  return input.map((entry) => entry);
};

const serializeAws_json1_1TerminateSessionRequest = (input: TerminateSessionRequest, context: __SerdeContext): any => {
  return {
    ...(input.SessionId !== undefined && { SessionId: input.SessionId }),
  };
};

const serializeAws_json1_1UpdateAssociationRequest = (
  input: UpdateAssociationRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ApplyOnlyAtCronInterval !== undefined && { ApplyOnlyAtCronInterval: input.ApplyOnlyAtCronInterval }),
    ...(input.AssociationId !== undefined && { AssociationId: input.AssociationId }),
    ...(input.AssociationName !== undefined && { AssociationName: input.AssociationName }),
    ...(input.AssociationVersion !== undefined && { AssociationVersion: input.AssociationVersion }),
    ...(input.AutomationTargetParameterName !== undefined && {
      AutomationTargetParameterName: input.AutomationTargetParameterName,
    }),
    ...(input.ComplianceSeverity !== undefined && { ComplianceSeverity: input.ComplianceSeverity }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.OutputLocation !== undefined && {
      OutputLocation: serializeAws_json1_1InstanceAssociationOutputLocation(input.OutputLocation, context),
    }),
    ...(input.Parameters !== undefined && { Parameters: serializeAws_json1_1Parameters(input.Parameters, context) }),
    ...(input.ScheduleExpression !== undefined && { ScheduleExpression: input.ScheduleExpression }),
    ...(input.SyncCompliance !== undefined && { SyncCompliance: input.SyncCompliance }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
  };
};

const serializeAws_json1_1UpdateAssociationStatusRequest = (
  input: UpdateAssociationStatusRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AssociationStatus !== undefined && {
      AssociationStatus: serializeAws_json1_1AssociationStatus(input.AssociationStatus, context),
    }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1UpdateDocumentDefaultVersionRequest = (
  input: UpdateDocumentDefaultVersionRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.Name !== undefined && { Name: input.Name }),
  };
};

const serializeAws_json1_1UpdateDocumentRequest = (input: UpdateDocumentRequest, context: __SerdeContext): any => {
  return {
    ...(input.Attachments !== undefined && {
      Attachments: serializeAws_json1_1AttachmentsSourceList(input.Attachments, context),
    }),
    ...(input.Content !== undefined && { Content: input.Content }),
    ...(input.DocumentFormat !== undefined && { DocumentFormat: input.DocumentFormat }),
    ...(input.DocumentVersion !== undefined && { DocumentVersion: input.DocumentVersion }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.TargetType !== undefined && { TargetType: input.TargetType }),
    ...(input.VersionName !== undefined && { VersionName: input.VersionName }),
  };
};

const serializeAws_json1_1UpdateMaintenanceWindowRequest = (
  input: UpdateMaintenanceWindowRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.AllowUnassociatedTargets !== undefined && { AllowUnassociatedTargets: input.AllowUnassociatedTargets }),
    ...(input.Cutoff !== undefined && { Cutoff: input.Cutoff }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.Duration !== undefined && { Duration: input.Duration }),
    ...(input.Enabled !== undefined && { Enabled: input.Enabled }),
    ...(input.EndDate !== undefined && { EndDate: input.EndDate }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Replace !== undefined && { Replace: input.Replace }),
    ...(input.Schedule !== undefined && { Schedule: input.Schedule }),
    ...(input.ScheduleOffset !== undefined && { ScheduleOffset: input.ScheduleOffset }),
    ...(input.ScheduleTimezone !== undefined && { ScheduleTimezone: input.ScheduleTimezone }),
    ...(input.StartDate !== undefined && { StartDate: input.StartDate }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
  };
};

const serializeAws_json1_1UpdateMaintenanceWindowTargetRequest = (
  input: UpdateMaintenanceWindowTargetRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.OwnerInformation !== undefined && { OwnerInformation: input.OwnerInformation }),
    ...(input.Replace !== undefined && { Replace: input.Replace }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
    ...(input.WindowTargetId !== undefined && { WindowTargetId: input.WindowTargetId }),
  };
};

const serializeAws_json1_1UpdateMaintenanceWindowTaskRequest = (
  input: UpdateMaintenanceWindowTaskRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.LoggingInfo !== undefined && {
      LoggingInfo: serializeAws_json1_1LoggingInfo(input.LoggingInfo, context),
    }),
    ...(input.MaxConcurrency !== undefined && { MaxConcurrency: input.MaxConcurrency }),
    ...(input.MaxErrors !== undefined && { MaxErrors: input.MaxErrors }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.Priority !== undefined && { Priority: input.Priority }),
    ...(input.Replace !== undefined && { Replace: input.Replace }),
    ...(input.ServiceRoleArn !== undefined && { ServiceRoleArn: input.ServiceRoleArn }),
    ...(input.Targets !== undefined && { Targets: serializeAws_json1_1Targets(input.Targets, context) }),
    ...(input.TaskArn !== undefined && { TaskArn: input.TaskArn }),
    ...(input.TaskInvocationParameters !== undefined && {
      TaskInvocationParameters: serializeAws_json1_1MaintenanceWindowTaskInvocationParameters(
        input.TaskInvocationParameters,
        context
      ),
    }),
    ...(input.TaskParameters !== undefined && {
      TaskParameters: serializeAws_json1_1MaintenanceWindowTaskParameters(input.TaskParameters, context),
    }),
    ...(input.WindowId !== undefined && { WindowId: input.WindowId }),
    ...(input.WindowTaskId !== undefined && { WindowTaskId: input.WindowTaskId }),
  };
};

const serializeAws_json1_1UpdateManagedInstanceRoleRequest = (
  input: UpdateManagedInstanceRoleRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.IamRole !== undefined && { IamRole: input.IamRole }),
    ...(input.InstanceId !== undefined && { InstanceId: input.InstanceId }),
  };
};

const serializeAws_json1_1UpdateOpsItemRequest = (input: UpdateOpsItemRequest, context: __SerdeContext): any => {
  return {
    ...(input.Category !== undefined && { Category: input.Category }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.Notifications !== undefined && {
      Notifications: serializeAws_json1_1OpsItemNotifications(input.Notifications, context),
    }),
    ...(input.OperationalData !== undefined && {
      OperationalData: serializeAws_json1_1OpsItemOperationalData(input.OperationalData, context),
    }),
    ...(input.OperationalDataToDelete !== undefined && {
      OperationalDataToDelete: serializeAws_json1_1OpsItemOpsDataKeysList(input.OperationalDataToDelete, context),
    }),
    ...(input.OpsItemId !== undefined && { OpsItemId: input.OpsItemId }),
    ...(input.Priority !== undefined && { Priority: input.Priority }),
    ...(input.RelatedOpsItems !== undefined && {
      RelatedOpsItems: serializeAws_json1_1RelatedOpsItems(input.RelatedOpsItems, context),
    }),
    ...(input.Severity !== undefined && { Severity: input.Severity }),
    ...(input.Status !== undefined && { Status: input.Status }),
    ...(input.Title !== undefined && { Title: input.Title }),
  };
};

const serializeAws_json1_1UpdatePatchBaselineRequest = (
  input: UpdatePatchBaselineRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.ApprovalRules !== undefined && {
      ApprovalRules: serializeAws_json1_1PatchRuleGroup(input.ApprovalRules, context),
    }),
    ...(input.ApprovedPatches !== undefined && {
      ApprovedPatches: serializeAws_json1_1PatchIdList(input.ApprovedPatches, context),
    }),
    ...(input.ApprovedPatchesComplianceLevel !== undefined && {
      ApprovedPatchesComplianceLevel: input.ApprovedPatchesComplianceLevel,
    }),
    ...(input.ApprovedPatchesEnableNonSecurity !== undefined && {
      ApprovedPatchesEnableNonSecurity: input.ApprovedPatchesEnableNonSecurity,
    }),
    ...(input.BaselineId !== undefined && { BaselineId: input.BaselineId }),
    ...(input.Description !== undefined && { Description: input.Description }),
    ...(input.GlobalFilters !== undefined && {
      GlobalFilters: serializeAws_json1_1PatchFilterGroup(input.GlobalFilters, context),
    }),
    ...(input.Name !== undefined && { Name: input.Name }),
    ...(input.RejectedPatches !== undefined && {
      RejectedPatches: serializeAws_json1_1PatchIdList(input.RejectedPatches, context),
    }),
    ...(input.RejectedPatchesAction !== undefined && { RejectedPatchesAction: input.RejectedPatchesAction }),
    ...(input.Replace !== undefined && { Replace: input.Replace }),
    ...(input.Sources !== undefined && { Sources: serializeAws_json1_1PatchSourceList(input.Sources, context) }),
  };
};

const serializeAws_json1_1UpdateResourceDataSyncRequest = (
  input: UpdateResourceDataSyncRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.SyncName !== undefined && { SyncName: input.SyncName }),
    ...(input.SyncSource !== undefined && {
      SyncSource: serializeAws_json1_1ResourceDataSyncSource(input.SyncSource, context),
    }),
    ...(input.SyncType !== undefined && { SyncType: input.SyncType }),
  };
};

const serializeAws_json1_1UpdateServiceSettingRequest = (
  input: UpdateServiceSettingRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.SettingId !== undefined && { SettingId: input.SettingId }),
    ...(input.SettingValue !== undefined && { SettingValue: input.SettingValue }),
  };
};

const deserializeAws_json1_1AccountIdList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1Accounts = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1AccountSharingInfo = (output: any, context: __SerdeContext): AccountSharingInfo => {
  return {
    AccountId: output.AccountId !== undefined && output.AccountId !== null ? output.AccountId : undefined,
    SharedDocumentVersion:
      output.SharedDocumentVersion !== undefined && output.SharedDocumentVersion !== null
        ? output.SharedDocumentVersion
        : undefined,
  } as any;
};

const deserializeAws_json1_1AccountSharingInfoList = (output: any, context: __SerdeContext): AccountSharingInfo[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AccountSharingInfo(entry, context));
};

const deserializeAws_json1_1Activation = (output: any, context: __SerdeContext): Activation => {
  return {
    ActivationId: output.ActivationId !== undefined && output.ActivationId !== null ? output.ActivationId : undefined,
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    DefaultInstanceName:
      output.DefaultInstanceName !== undefined && output.DefaultInstanceName !== null
        ? output.DefaultInstanceName
        : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    ExpirationDate:
      output.ExpirationDate !== undefined && output.ExpirationDate !== null
        ? new Date(Math.round(output.ExpirationDate * 1000))
        : undefined,
    Expired: output.Expired !== undefined && output.Expired !== null ? output.Expired : undefined,
    IamRole: output.IamRole !== undefined && output.IamRole !== null ? output.IamRole : undefined,
    RegistrationLimit:
      output.RegistrationLimit !== undefined && output.RegistrationLimit !== null
        ? output.RegistrationLimit
        : undefined,
    RegistrationsCount:
      output.RegistrationsCount !== undefined && output.RegistrationsCount !== null
        ? output.RegistrationsCount
        : undefined,
    Tags:
      output.Tags !== undefined && output.Tags !== null
        ? deserializeAws_json1_1TagList(output.Tags, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ActivationList = (output: any, context: __SerdeContext): Activation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Activation(entry, context));
};

const deserializeAws_json1_1AddTagsToResourceResult = (
  output: any,
  context: __SerdeContext
): AddTagsToResourceResult => {
  return {} as any;
};

const deserializeAws_json1_1AlreadyExistsException = (output: any, context: __SerdeContext): AlreadyExistsException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AssociatedInstances = (output: any, context: __SerdeContext): AssociatedInstances => {
  return {} as any;
};

const deserializeAws_json1_1Association = (output: any, context: __SerdeContext): Association => {
  return {
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationName:
      output.AssociationName !== undefined && output.AssociationName !== null ? output.AssociationName : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    LastExecutionDate:
      output.LastExecutionDate !== undefined && output.LastExecutionDate !== null
        ? new Date(Math.round(output.LastExecutionDate * 1000))
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Overview:
      output.Overview !== undefined && output.Overview !== null
        ? deserializeAws_json1_1AssociationOverview(output.Overview, context)
        : undefined,
    ScheduleExpression:
      output.ScheduleExpression !== undefined && output.ScheduleExpression !== null
        ? output.ScheduleExpression
        : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationAlreadyExists = (
  output: any,
  context: __SerdeContext
): AssociationAlreadyExists => {
  return {} as any;
};

const deserializeAws_json1_1AssociationDescription = (output: any, context: __SerdeContext): AssociationDescription => {
  return {
    ApplyOnlyAtCronInterval:
      output.ApplyOnlyAtCronInterval !== undefined && output.ApplyOnlyAtCronInterval !== null
        ? output.ApplyOnlyAtCronInterval
        : undefined,
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationName:
      output.AssociationName !== undefined && output.AssociationName !== null ? output.AssociationName : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    AutomationTargetParameterName:
      output.AutomationTargetParameterName !== undefined && output.AutomationTargetParameterName !== null
        ? output.AutomationTargetParameterName
        : undefined,
    ComplianceSeverity:
      output.ComplianceSeverity !== undefined && output.ComplianceSeverity !== null
        ? output.ComplianceSeverity
        : undefined,
    Date: output.Date !== undefined && output.Date !== null ? new Date(Math.round(output.Date * 1000)) : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    LastExecutionDate:
      output.LastExecutionDate !== undefined && output.LastExecutionDate !== null
        ? new Date(Math.round(output.LastExecutionDate * 1000))
        : undefined,
    LastSuccessfulExecutionDate:
      output.LastSuccessfulExecutionDate !== undefined && output.LastSuccessfulExecutionDate !== null
        ? new Date(Math.round(output.LastSuccessfulExecutionDate * 1000))
        : undefined,
    LastUpdateAssociationDate:
      output.LastUpdateAssociationDate !== undefined && output.LastUpdateAssociationDate !== null
        ? new Date(Math.round(output.LastUpdateAssociationDate * 1000))
        : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OutputLocation:
      output.OutputLocation !== undefined && output.OutputLocation !== null
        ? deserializeAws_json1_1InstanceAssociationOutputLocation(output.OutputLocation, context)
        : undefined,
    Overview:
      output.Overview !== undefined && output.Overview !== null
        ? deserializeAws_json1_1AssociationOverview(output.Overview, context)
        : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1Parameters(output.Parameters, context)
        : undefined,
    ScheduleExpression:
      output.ScheduleExpression !== undefined && output.ScheduleExpression !== null
        ? output.ScheduleExpression
        : undefined,
    Status:
      output.Status !== undefined && output.Status !== null
        ? deserializeAws_json1_1AssociationStatus(output.Status, context)
        : undefined,
    SyncCompliance:
      output.SyncCompliance !== undefined && output.SyncCompliance !== null ? output.SyncCompliance : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationDescriptionList = (
  output: any,
  context: __SerdeContext
): AssociationDescription[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AssociationDescription(entry, context));
};

const deserializeAws_json1_1AssociationDoesNotExist = (
  output: any,
  context: __SerdeContext
): AssociationDoesNotExist => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationExecution = (output: any, context: __SerdeContext): AssociationExecution => {
  return {
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    CreatedTime:
      output.CreatedTime !== undefined && output.CreatedTime !== null
        ? new Date(Math.round(output.CreatedTime * 1000))
        : undefined,
    DetailedStatus:
      output.DetailedStatus !== undefined && output.DetailedStatus !== null ? output.DetailedStatus : undefined,
    ExecutionId: output.ExecutionId !== undefined && output.ExecutionId !== null ? output.ExecutionId : undefined,
    LastExecutionDate:
      output.LastExecutionDate !== undefined && output.LastExecutionDate !== null
        ? new Date(Math.round(output.LastExecutionDate * 1000))
        : undefined,
    ResourceCountByStatus:
      output.ResourceCountByStatus !== undefined && output.ResourceCountByStatus !== null
        ? output.ResourceCountByStatus
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationExecutionDoesNotExist = (
  output: any,
  context: __SerdeContext
): AssociationExecutionDoesNotExist => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationExecutionsList = (
  output: any,
  context: __SerdeContext
): AssociationExecution[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AssociationExecution(entry, context));
};

const deserializeAws_json1_1AssociationExecutionTarget = (
  output: any,
  context: __SerdeContext
): AssociationExecutionTarget => {
  return {
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    DetailedStatus:
      output.DetailedStatus !== undefined && output.DetailedStatus !== null ? output.DetailedStatus : undefined,
    ExecutionId: output.ExecutionId !== undefined && output.ExecutionId !== null ? output.ExecutionId : undefined,
    LastExecutionDate:
      output.LastExecutionDate !== undefined && output.LastExecutionDate !== null
        ? new Date(Math.round(output.LastExecutionDate * 1000))
        : undefined,
    OutputSource:
      output.OutputSource !== undefined && output.OutputSource !== null
        ? deserializeAws_json1_1OutputSource(output.OutputSource, context)
        : undefined,
    ResourceId: output.ResourceId !== undefined && output.ResourceId !== null ? output.ResourceId : undefined,
    ResourceType: output.ResourceType !== undefined && output.ResourceType !== null ? output.ResourceType : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationExecutionTargetsList = (
  output: any,
  context: __SerdeContext
): AssociationExecutionTarget[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AssociationExecutionTarget(entry, context));
};

const deserializeAws_json1_1AssociationLimitExceeded = (
  output: any,
  context: __SerdeContext
): AssociationLimitExceeded => {
  return {} as any;
};

const deserializeAws_json1_1AssociationList = (output: any, context: __SerdeContext): Association[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Association(entry, context));
};

const deserializeAws_json1_1AssociationOverview = (output: any, context: __SerdeContext): AssociationOverview => {
  return {
    AssociationStatusAggregatedCount:
      output.AssociationStatusAggregatedCount !== undefined && output.AssociationStatusAggregatedCount !== null
        ? deserializeAws_json1_1AssociationStatusAggregatedCount(output.AssociationStatusAggregatedCount, context)
        : undefined,
    DetailedStatus:
      output.DetailedStatus !== undefined && output.DetailedStatus !== null ? output.DetailedStatus : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationStatus = (output: any, context: __SerdeContext): AssociationStatus => {
  return {
    AdditionalInfo:
      output.AdditionalInfo !== undefined && output.AdditionalInfo !== null ? output.AdditionalInfo : undefined,
    Date: output.Date !== undefined && output.Date !== null ? new Date(Math.round(output.Date * 1000)) : undefined,
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationStatusAggregatedCount = (
  output: any,
  context: __SerdeContext
): { [key: string]: number } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: number }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1AssociationVersionInfo = (output: any, context: __SerdeContext): AssociationVersionInfo => {
  return {
    ApplyOnlyAtCronInterval:
      output.ApplyOnlyAtCronInterval !== undefined && output.ApplyOnlyAtCronInterval !== null
        ? output.ApplyOnlyAtCronInterval
        : undefined,
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationName:
      output.AssociationName !== undefined && output.AssociationName !== null ? output.AssociationName : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    ComplianceSeverity:
      output.ComplianceSeverity !== undefined && output.ComplianceSeverity !== null
        ? output.ComplianceSeverity
        : undefined,
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OutputLocation:
      output.OutputLocation !== undefined && output.OutputLocation !== null
        ? deserializeAws_json1_1InstanceAssociationOutputLocation(output.OutputLocation, context)
        : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1Parameters(output.Parameters, context)
        : undefined,
    ScheduleExpression:
      output.ScheduleExpression !== undefined && output.ScheduleExpression !== null
        ? output.ScheduleExpression
        : undefined,
    SyncCompliance:
      output.SyncCompliance !== undefined && output.SyncCompliance !== null ? output.SyncCompliance : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationVersionLimitExceeded = (
  output: any,
  context: __SerdeContext
): AssociationVersionLimitExceeded => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AssociationVersionList = (
  output: any,
  context: __SerdeContext
): AssociationVersionInfo[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AssociationVersionInfo(entry, context));
};

const deserializeAws_json1_1AttachmentContent = (output: any, context: __SerdeContext): AttachmentContent => {
  return {
    Hash: output.Hash !== undefined && output.Hash !== null ? output.Hash : undefined,
    HashType: output.HashType !== undefined && output.HashType !== null ? output.HashType : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Size: output.Size !== undefined && output.Size !== null ? output.Size : undefined,
    Url: output.Url !== undefined && output.Url !== null ? output.Url : undefined,
  } as any;
};

const deserializeAws_json1_1AttachmentContentList = (output: any, context: __SerdeContext): AttachmentContent[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AttachmentContent(entry, context));
};

const deserializeAws_json1_1AttachmentInformation = (output: any, context: __SerdeContext): AttachmentInformation => {
  return {
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
  } as any;
};

const deserializeAws_json1_1AttachmentInformationList = (
  output: any,
  context: __SerdeContext
): AttachmentInformation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AttachmentInformation(entry, context));
};

const deserializeAws_json1_1AutomationDefinitionNotFoundException = (
  output: any,
  context: __SerdeContext
): AutomationDefinitionNotFoundException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AutomationDefinitionVersionNotFoundException = (
  output: any,
  context: __SerdeContext
): AutomationDefinitionVersionNotFoundException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AutomationExecution = (output: any, context: __SerdeContext): AutomationExecution => {
  return {
    AutomationExecutionId:
      output.AutomationExecutionId !== undefined && output.AutomationExecutionId !== null
        ? output.AutomationExecutionId
        : undefined,
    AutomationExecutionStatus:
      output.AutomationExecutionStatus !== undefined && output.AutomationExecutionStatus !== null
        ? output.AutomationExecutionStatus
        : undefined,
    CurrentAction:
      output.CurrentAction !== undefined && output.CurrentAction !== null ? output.CurrentAction : undefined,
    CurrentStepName:
      output.CurrentStepName !== undefined && output.CurrentStepName !== null ? output.CurrentStepName : undefined,
    DocumentName: output.DocumentName !== undefined && output.DocumentName !== null ? output.DocumentName : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    ExecutedBy: output.ExecutedBy !== undefined && output.ExecutedBy !== null ? output.ExecutedBy : undefined,
    ExecutionEndTime:
      output.ExecutionEndTime !== undefined && output.ExecutionEndTime !== null
        ? new Date(Math.round(output.ExecutionEndTime * 1000))
        : undefined,
    ExecutionStartTime:
      output.ExecutionStartTime !== undefined && output.ExecutionStartTime !== null
        ? new Date(Math.round(output.ExecutionStartTime * 1000))
        : undefined,
    FailureMessage:
      output.FailureMessage !== undefined && output.FailureMessage !== null ? output.FailureMessage : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Mode: output.Mode !== undefined && output.Mode !== null ? output.Mode : undefined,
    Outputs:
      output.Outputs !== undefined && output.Outputs !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.Outputs, context)
        : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.Parameters, context)
        : undefined,
    ParentAutomationExecutionId:
      output.ParentAutomationExecutionId !== undefined && output.ParentAutomationExecutionId !== null
        ? output.ParentAutomationExecutionId
        : undefined,
    ProgressCounters:
      output.ProgressCounters !== undefined && output.ProgressCounters !== null
        ? deserializeAws_json1_1ProgressCounters(output.ProgressCounters, context)
        : undefined,
    ResolvedTargets:
      output.ResolvedTargets !== undefined && output.ResolvedTargets !== null
        ? deserializeAws_json1_1ResolvedTargets(output.ResolvedTargets, context)
        : undefined,
    StepExecutions:
      output.StepExecutions !== undefined && output.StepExecutions !== null
        ? deserializeAws_json1_1StepExecutionList(output.StepExecutions, context)
        : undefined,
    StepExecutionsTruncated:
      output.StepExecutionsTruncated !== undefined && output.StepExecutionsTruncated !== null
        ? output.StepExecutionsTruncated
        : undefined,
    Target: output.Target !== undefined && output.Target !== null ? output.Target : undefined,
    TargetLocations:
      output.TargetLocations !== undefined && output.TargetLocations !== null
        ? deserializeAws_json1_1TargetLocations(output.TargetLocations, context)
        : undefined,
    TargetMaps:
      output.TargetMaps !== undefined && output.TargetMaps !== null
        ? deserializeAws_json1_1TargetMaps(output.TargetMaps, context)
        : undefined,
    TargetParameterName:
      output.TargetParameterName !== undefined && output.TargetParameterName !== null
        ? output.TargetParameterName
        : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1AutomationExecutionLimitExceededException = (
  output: any,
  context: __SerdeContext
): AutomationExecutionLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AutomationExecutionMetadata = (
  output: any,
  context: __SerdeContext
): AutomationExecutionMetadata => {
  return {
    AutomationExecutionId:
      output.AutomationExecutionId !== undefined && output.AutomationExecutionId !== null
        ? output.AutomationExecutionId
        : undefined,
    AutomationExecutionStatus:
      output.AutomationExecutionStatus !== undefined && output.AutomationExecutionStatus !== null
        ? output.AutomationExecutionStatus
        : undefined,
    AutomationType:
      output.AutomationType !== undefined && output.AutomationType !== null ? output.AutomationType : undefined,
    CurrentAction:
      output.CurrentAction !== undefined && output.CurrentAction !== null ? output.CurrentAction : undefined,
    CurrentStepName:
      output.CurrentStepName !== undefined && output.CurrentStepName !== null ? output.CurrentStepName : undefined,
    DocumentName: output.DocumentName !== undefined && output.DocumentName !== null ? output.DocumentName : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    ExecutedBy: output.ExecutedBy !== undefined && output.ExecutedBy !== null ? output.ExecutedBy : undefined,
    ExecutionEndTime:
      output.ExecutionEndTime !== undefined && output.ExecutionEndTime !== null
        ? new Date(Math.round(output.ExecutionEndTime * 1000))
        : undefined,
    ExecutionStartTime:
      output.ExecutionStartTime !== undefined && output.ExecutionStartTime !== null
        ? new Date(Math.round(output.ExecutionStartTime * 1000))
        : undefined,
    FailureMessage:
      output.FailureMessage !== undefined && output.FailureMessage !== null ? output.FailureMessage : undefined,
    LogFile: output.LogFile !== undefined && output.LogFile !== null ? output.LogFile : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Mode: output.Mode !== undefined && output.Mode !== null ? output.Mode : undefined,
    Outputs:
      output.Outputs !== undefined && output.Outputs !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.Outputs, context)
        : undefined,
    ParentAutomationExecutionId:
      output.ParentAutomationExecutionId !== undefined && output.ParentAutomationExecutionId !== null
        ? output.ParentAutomationExecutionId
        : undefined,
    ResolvedTargets:
      output.ResolvedTargets !== undefined && output.ResolvedTargets !== null
        ? deserializeAws_json1_1ResolvedTargets(output.ResolvedTargets, context)
        : undefined,
    Target: output.Target !== undefined && output.Target !== null ? output.Target : undefined,
    TargetMaps:
      output.TargetMaps !== undefined && output.TargetMaps !== null
        ? deserializeAws_json1_1TargetMaps(output.TargetMaps, context)
        : undefined,
    TargetParameterName:
      output.TargetParameterName !== undefined && output.TargetParameterName !== null
        ? output.TargetParameterName
        : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1AutomationExecutionMetadataList = (
  output: any,
  context: __SerdeContext
): AutomationExecutionMetadata[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1AutomationExecutionMetadata(entry, context));
};

const deserializeAws_json1_1AutomationExecutionNotFoundException = (
  output: any,
  context: __SerdeContext
): AutomationExecutionNotFoundException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1AutomationParameterMap = (
  output: any,
  context: __SerdeContext
): { [key: string]: string[] } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1AutomationParameterValueList(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1AutomationParameterValueList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1AutomationStepNotFoundException = (
  output: any,
  context: __SerdeContext
): AutomationStepNotFoundException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1CancelCommandResult = (output: any, context: __SerdeContext): CancelCommandResult => {
  return {} as any;
};

const deserializeAws_json1_1CancelMaintenanceWindowExecutionResult = (
  output: any,
  context: __SerdeContext
): CancelMaintenanceWindowExecutionResult => {
  return {
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
  } as any;
};

const deserializeAws_json1_1CloudWatchOutputConfig = (output: any, context: __SerdeContext): CloudWatchOutputConfig => {
  return {
    CloudWatchLogGroupName:
      output.CloudWatchLogGroupName !== undefined && output.CloudWatchLogGroupName !== null
        ? output.CloudWatchLogGroupName
        : undefined,
    CloudWatchOutputEnabled:
      output.CloudWatchOutputEnabled !== undefined && output.CloudWatchOutputEnabled !== null
        ? output.CloudWatchOutputEnabled
        : undefined,
  } as any;
};

const deserializeAws_json1_1Command = (output: any, context: __SerdeContext): Command => {
  return {
    CloudWatchOutputConfig:
      output.CloudWatchOutputConfig !== undefined && output.CloudWatchOutputConfig !== null
        ? deserializeAws_json1_1CloudWatchOutputConfig(output.CloudWatchOutputConfig, context)
        : undefined,
    CommandId: output.CommandId !== undefined && output.CommandId !== null ? output.CommandId : undefined,
    Comment: output.Comment !== undefined && output.Comment !== null ? output.Comment : undefined,
    CompletedCount:
      output.CompletedCount !== undefined && output.CompletedCount !== null ? output.CompletedCount : undefined,
    DeliveryTimedOutCount:
      output.DeliveryTimedOutCount !== undefined && output.DeliveryTimedOutCount !== null
        ? output.DeliveryTimedOutCount
        : undefined,
    DocumentName: output.DocumentName !== undefined && output.DocumentName !== null ? output.DocumentName : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    ErrorCount: output.ErrorCount !== undefined && output.ErrorCount !== null ? output.ErrorCount : undefined,
    ExpiresAfter:
      output.ExpiresAfter !== undefined && output.ExpiresAfter !== null
        ? new Date(Math.round(output.ExpiresAfter * 1000))
        : undefined,
    InstanceIds:
      output.InstanceIds !== undefined && output.InstanceIds !== null
        ? deserializeAws_json1_1InstanceIdList(output.InstanceIds, context)
        : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    NotificationConfig:
      output.NotificationConfig !== undefined && output.NotificationConfig !== null
        ? deserializeAws_json1_1NotificationConfig(output.NotificationConfig, context)
        : undefined,
    OutputS3BucketName:
      output.OutputS3BucketName !== undefined && output.OutputS3BucketName !== null
        ? output.OutputS3BucketName
        : undefined,
    OutputS3KeyPrefix:
      output.OutputS3KeyPrefix !== undefined && output.OutputS3KeyPrefix !== null
        ? output.OutputS3KeyPrefix
        : undefined,
    OutputS3Region:
      output.OutputS3Region !== undefined && output.OutputS3Region !== null ? output.OutputS3Region : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1Parameters(output.Parameters, context)
        : undefined,
    RequestedDateTime:
      output.RequestedDateTime !== undefined && output.RequestedDateTime !== null
        ? new Date(Math.round(output.RequestedDateTime * 1000))
        : undefined,
    ServiceRole: output.ServiceRole !== undefined && output.ServiceRole !== null ? output.ServiceRole : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TargetCount: output.TargetCount !== undefined && output.TargetCount !== null ? output.TargetCount : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    TimeoutSeconds:
      output.TimeoutSeconds !== undefined && output.TimeoutSeconds !== null ? output.TimeoutSeconds : undefined,
  } as any;
};

const deserializeAws_json1_1CommandInvocation = (output: any, context: __SerdeContext): CommandInvocation => {
  return {
    CloudWatchOutputConfig:
      output.CloudWatchOutputConfig !== undefined && output.CloudWatchOutputConfig !== null
        ? deserializeAws_json1_1CloudWatchOutputConfig(output.CloudWatchOutputConfig, context)
        : undefined,
    CommandId: output.CommandId !== undefined && output.CommandId !== null ? output.CommandId : undefined,
    CommandPlugins:
      output.CommandPlugins !== undefined && output.CommandPlugins !== null
        ? deserializeAws_json1_1CommandPluginList(output.CommandPlugins, context)
        : undefined,
    Comment: output.Comment !== undefined && output.Comment !== null ? output.Comment : undefined,
    DocumentName: output.DocumentName !== undefined && output.DocumentName !== null ? output.DocumentName : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    InstanceName: output.InstanceName !== undefined && output.InstanceName !== null ? output.InstanceName : undefined,
    NotificationConfig:
      output.NotificationConfig !== undefined && output.NotificationConfig !== null
        ? deserializeAws_json1_1NotificationConfig(output.NotificationConfig, context)
        : undefined,
    RequestedDateTime:
      output.RequestedDateTime !== undefined && output.RequestedDateTime !== null
        ? new Date(Math.round(output.RequestedDateTime * 1000))
        : undefined,
    ServiceRole: output.ServiceRole !== undefined && output.ServiceRole !== null ? output.ServiceRole : undefined,
    StandardErrorUrl:
      output.StandardErrorUrl !== undefined && output.StandardErrorUrl !== null ? output.StandardErrorUrl : undefined,
    StandardOutputUrl:
      output.StandardOutputUrl !== undefined && output.StandardOutputUrl !== null
        ? output.StandardOutputUrl
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TraceOutput: output.TraceOutput !== undefined && output.TraceOutput !== null ? output.TraceOutput : undefined,
  } as any;
};

const deserializeAws_json1_1CommandInvocationList = (output: any, context: __SerdeContext): CommandInvocation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1CommandInvocation(entry, context));
};

const deserializeAws_json1_1CommandList = (output: any, context: __SerdeContext): Command[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Command(entry, context));
};

const deserializeAws_json1_1CommandPlugin = (output: any, context: __SerdeContext): CommandPlugin => {
  return {
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Output: output.Output !== undefined && output.Output !== null ? output.Output : undefined,
    OutputS3BucketName:
      output.OutputS3BucketName !== undefined && output.OutputS3BucketName !== null
        ? output.OutputS3BucketName
        : undefined,
    OutputS3KeyPrefix:
      output.OutputS3KeyPrefix !== undefined && output.OutputS3KeyPrefix !== null
        ? output.OutputS3KeyPrefix
        : undefined,
    OutputS3Region:
      output.OutputS3Region !== undefined && output.OutputS3Region !== null ? output.OutputS3Region : undefined,
    ResponseCode: output.ResponseCode !== undefined && output.ResponseCode !== null ? output.ResponseCode : undefined,
    ResponseFinishDateTime:
      output.ResponseFinishDateTime !== undefined && output.ResponseFinishDateTime !== null
        ? new Date(Math.round(output.ResponseFinishDateTime * 1000))
        : undefined,
    ResponseStartDateTime:
      output.ResponseStartDateTime !== undefined && output.ResponseStartDateTime !== null
        ? new Date(Math.round(output.ResponseStartDateTime * 1000))
        : undefined,
    StandardErrorUrl:
      output.StandardErrorUrl !== undefined && output.StandardErrorUrl !== null ? output.StandardErrorUrl : undefined,
    StandardOutputUrl:
      output.StandardOutputUrl !== undefined && output.StandardOutputUrl !== null
        ? output.StandardOutputUrl
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
  } as any;
};

const deserializeAws_json1_1CommandPluginList = (output: any, context: __SerdeContext): CommandPlugin[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1CommandPlugin(entry, context));
};

const deserializeAws_json1_1ComplianceExecutionSummary = (
  output: any,
  context: __SerdeContext
): ComplianceExecutionSummary => {
  return {
    ExecutionId: output.ExecutionId !== undefined && output.ExecutionId !== null ? output.ExecutionId : undefined,
    ExecutionTime:
      output.ExecutionTime !== undefined && output.ExecutionTime !== null
        ? new Date(Math.round(output.ExecutionTime * 1000))
        : undefined,
    ExecutionType:
      output.ExecutionType !== undefined && output.ExecutionType !== null ? output.ExecutionType : undefined,
  } as any;
};

const deserializeAws_json1_1ComplianceItem = (output: any, context: __SerdeContext): ComplianceItem => {
  return {
    ComplianceType:
      output.ComplianceType !== undefined && output.ComplianceType !== null ? output.ComplianceType : undefined,
    Details:
      output.Details !== undefined && output.Details !== null
        ? deserializeAws_json1_1ComplianceItemDetails(output.Details, context)
        : undefined,
    ExecutionSummary:
      output.ExecutionSummary !== undefined && output.ExecutionSummary !== null
        ? deserializeAws_json1_1ComplianceExecutionSummary(output.ExecutionSummary, context)
        : undefined,
    Id: output.Id !== undefined && output.Id !== null ? output.Id : undefined,
    ResourceId: output.ResourceId !== undefined && output.ResourceId !== null ? output.ResourceId : undefined,
    ResourceType: output.ResourceType !== undefined && output.ResourceType !== null ? output.ResourceType : undefined,
    Severity: output.Severity !== undefined && output.Severity !== null ? output.Severity : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    Title: output.Title !== undefined && output.Title !== null ? output.Title : undefined,
  } as any;
};

const deserializeAws_json1_1ComplianceItemDetails = (
  output: any,
  context: __SerdeContext
): { [key: string]: string } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1ComplianceItemList = (output: any, context: __SerdeContext): ComplianceItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ComplianceItem(entry, context));
};

const deserializeAws_json1_1ComplianceSummaryItem = (output: any, context: __SerdeContext): ComplianceSummaryItem => {
  return {
    ComplianceType:
      output.ComplianceType !== undefined && output.ComplianceType !== null ? output.ComplianceType : undefined,
    CompliantSummary:
      output.CompliantSummary !== undefined && output.CompliantSummary !== null
        ? deserializeAws_json1_1CompliantSummary(output.CompliantSummary, context)
        : undefined,
    NonCompliantSummary:
      output.NonCompliantSummary !== undefined && output.NonCompliantSummary !== null
        ? deserializeAws_json1_1NonCompliantSummary(output.NonCompliantSummary, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ComplianceSummaryItemList = (
  output: any,
  context: __SerdeContext
): ComplianceSummaryItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ComplianceSummaryItem(entry, context));
};

const deserializeAws_json1_1ComplianceTypeCountLimitExceededException = (
  output: any,
  context: __SerdeContext
): ComplianceTypeCountLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1CompliantSummary = (output: any, context: __SerdeContext): CompliantSummary => {
  return {
    CompliantCount:
      output.CompliantCount !== undefined && output.CompliantCount !== null ? output.CompliantCount : undefined,
    SeveritySummary:
      output.SeveritySummary !== undefined && output.SeveritySummary !== null
        ? deserializeAws_json1_1SeveritySummary(output.SeveritySummary, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1CreateActivationResult = (output: any, context: __SerdeContext): CreateActivationResult => {
  return {
    ActivationCode:
      output.ActivationCode !== undefined && output.ActivationCode !== null ? output.ActivationCode : undefined,
    ActivationId: output.ActivationId !== undefined && output.ActivationId !== null ? output.ActivationId : undefined,
  } as any;
};

const deserializeAws_json1_1CreateAssociationBatchRequestEntry = (
  output: any,
  context: __SerdeContext
): CreateAssociationBatchRequestEntry => {
  return {
    ApplyOnlyAtCronInterval:
      output.ApplyOnlyAtCronInterval !== undefined && output.ApplyOnlyAtCronInterval !== null
        ? output.ApplyOnlyAtCronInterval
        : undefined,
    AssociationName:
      output.AssociationName !== undefined && output.AssociationName !== null ? output.AssociationName : undefined,
    AutomationTargetParameterName:
      output.AutomationTargetParameterName !== undefined && output.AutomationTargetParameterName !== null
        ? output.AutomationTargetParameterName
        : undefined,
    ComplianceSeverity:
      output.ComplianceSeverity !== undefined && output.ComplianceSeverity !== null
        ? output.ComplianceSeverity
        : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OutputLocation:
      output.OutputLocation !== undefined && output.OutputLocation !== null
        ? deserializeAws_json1_1InstanceAssociationOutputLocation(output.OutputLocation, context)
        : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1Parameters(output.Parameters, context)
        : undefined,
    ScheduleExpression:
      output.ScheduleExpression !== undefined && output.ScheduleExpression !== null
        ? output.ScheduleExpression
        : undefined,
    SyncCompliance:
      output.SyncCompliance !== undefined && output.SyncCompliance !== null ? output.SyncCompliance : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1CreateAssociationBatchResult = (
  output: any,
  context: __SerdeContext
): CreateAssociationBatchResult => {
  return {
    Failed:
      output.Failed !== undefined && output.Failed !== null
        ? deserializeAws_json1_1FailedCreateAssociationList(output.Failed, context)
        : undefined,
    Successful:
      output.Successful !== undefined && output.Successful !== null
        ? deserializeAws_json1_1AssociationDescriptionList(output.Successful, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1CreateAssociationResult = (
  output: any,
  context: __SerdeContext
): CreateAssociationResult => {
  return {
    AssociationDescription:
      output.AssociationDescription !== undefined && output.AssociationDescription !== null
        ? deserializeAws_json1_1AssociationDescription(output.AssociationDescription, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1CreateDocumentResult = (output: any, context: __SerdeContext): CreateDocumentResult => {
  return {
    DocumentDescription:
      output.DocumentDescription !== undefined && output.DocumentDescription !== null
        ? deserializeAws_json1_1DocumentDescription(output.DocumentDescription, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1CreateMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): CreateMaintenanceWindowResult => {
  return {
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1CreateOpsItemResponse = (output: any, context: __SerdeContext): CreateOpsItemResponse => {
  return {
    OpsItemId: output.OpsItemId !== undefined && output.OpsItemId !== null ? output.OpsItemId : undefined,
  } as any;
};

const deserializeAws_json1_1CreatePatchBaselineResult = (
  output: any,
  context: __SerdeContext
): CreatePatchBaselineResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
  } as any;
};

const deserializeAws_json1_1CreateResourceDataSyncResult = (
  output: any,
  context: __SerdeContext
): CreateResourceDataSyncResult => {
  return {} as any;
};

const deserializeAws_json1_1CustomSchemaCountLimitExceededException = (
  output: any,
  context: __SerdeContext
): CustomSchemaCountLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DeleteActivationResult = (output: any, context: __SerdeContext): DeleteActivationResult => {
  return {} as any;
};

const deserializeAws_json1_1DeleteAssociationResult = (
  output: any,
  context: __SerdeContext
): DeleteAssociationResult => {
  return {} as any;
};

const deserializeAws_json1_1DeleteDocumentResult = (output: any, context: __SerdeContext): DeleteDocumentResult => {
  return {} as any;
};

const deserializeAws_json1_1DeleteInventoryResult = (output: any, context: __SerdeContext): DeleteInventoryResult => {
  return {
    DeletionId: output.DeletionId !== undefined && output.DeletionId !== null ? output.DeletionId : undefined,
    DeletionSummary:
      output.DeletionSummary !== undefined && output.DeletionSummary !== null
        ? deserializeAws_json1_1InventoryDeletionSummary(output.DeletionSummary, context)
        : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1DeleteMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): DeleteMaintenanceWindowResult => {
  return {
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1DeleteParameterResult = (output: any, context: __SerdeContext): DeleteParameterResult => {
  return {} as any;
};

const deserializeAws_json1_1DeleteParametersResult = (output: any, context: __SerdeContext): DeleteParametersResult => {
  return {
    DeletedParameters:
      output.DeletedParameters !== undefined && output.DeletedParameters !== null
        ? deserializeAws_json1_1ParameterNameList(output.DeletedParameters, context)
        : undefined,
    InvalidParameters:
      output.InvalidParameters !== undefined && output.InvalidParameters !== null
        ? deserializeAws_json1_1ParameterNameList(output.InvalidParameters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DeletePatchBaselineResult = (
  output: any,
  context: __SerdeContext
): DeletePatchBaselineResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
  } as any;
};

const deserializeAws_json1_1DeleteResourceDataSyncResult = (
  output: any,
  context: __SerdeContext
): DeleteResourceDataSyncResult => {
  return {} as any;
};

const deserializeAws_json1_1DeregisterManagedInstanceResult = (
  output: any,
  context: __SerdeContext
): DeregisterManagedInstanceResult => {
  return {} as any;
};

const deserializeAws_json1_1DeregisterPatchBaselineForPatchGroupResult = (
  output: any,
  context: __SerdeContext
): DeregisterPatchBaselineForPatchGroupResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    PatchGroup: output.PatchGroup !== undefined && output.PatchGroup !== null ? output.PatchGroup : undefined,
  } as any;
};

const deserializeAws_json1_1DeregisterTargetFromMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): DeregisterTargetFromMaintenanceWindowResult => {
  return {
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTargetId:
      output.WindowTargetId !== undefined && output.WindowTargetId !== null ? output.WindowTargetId : undefined,
  } as any;
};

const deserializeAws_json1_1DeregisterTaskFromMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): DeregisterTaskFromMaintenanceWindowResult => {
  return {
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTaskId: output.WindowTaskId !== undefined && output.WindowTaskId !== null ? output.WindowTaskId : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeActivationsResult = (
  output: any,
  context: __SerdeContext
): DescribeActivationsResult => {
  return {
    ActivationList:
      output.ActivationList !== undefined && output.ActivationList !== null
        ? deserializeAws_json1_1ActivationList(output.ActivationList, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeAssociationExecutionsResult = (
  output: any,
  context: __SerdeContext
): DescribeAssociationExecutionsResult => {
  return {
    AssociationExecutions:
      output.AssociationExecutions !== undefined && output.AssociationExecutions !== null
        ? deserializeAws_json1_1AssociationExecutionsList(output.AssociationExecutions, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeAssociationExecutionTargetsResult = (
  output: any,
  context: __SerdeContext
): DescribeAssociationExecutionTargetsResult => {
  return {
    AssociationExecutionTargets:
      output.AssociationExecutionTargets !== undefined && output.AssociationExecutionTargets !== null
        ? deserializeAws_json1_1AssociationExecutionTargetsList(output.AssociationExecutionTargets, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeAssociationResult = (
  output: any,
  context: __SerdeContext
): DescribeAssociationResult => {
  return {
    AssociationDescription:
      output.AssociationDescription !== undefined && output.AssociationDescription !== null
        ? deserializeAws_json1_1AssociationDescription(output.AssociationDescription, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeAutomationExecutionsResult = (
  output: any,
  context: __SerdeContext
): DescribeAutomationExecutionsResult => {
  return {
    AutomationExecutionMetadataList:
      output.AutomationExecutionMetadataList !== undefined && output.AutomationExecutionMetadataList !== null
        ? deserializeAws_json1_1AutomationExecutionMetadataList(output.AutomationExecutionMetadataList, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeAutomationStepExecutionsResult = (
  output: any,
  context: __SerdeContext
): DescribeAutomationStepExecutionsResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    StepExecutions:
      output.StepExecutions !== undefined && output.StepExecutions !== null
        ? deserializeAws_json1_1StepExecutionList(output.StepExecutions, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeAvailablePatchesResult = (
  output: any,
  context: __SerdeContext
): DescribeAvailablePatchesResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Patches:
      output.Patches !== undefined && output.Patches !== null
        ? deserializeAws_json1_1PatchList(output.Patches, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeDocumentPermissionResponse = (
  output: any,
  context: __SerdeContext
): DescribeDocumentPermissionResponse => {
  return {
    AccountIds:
      output.AccountIds !== undefined && output.AccountIds !== null
        ? deserializeAws_json1_1AccountIdList(output.AccountIds, context)
        : undefined,
    AccountSharingInfoList:
      output.AccountSharingInfoList !== undefined && output.AccountSharingInfoList !== null
        ? deserializeAws_json1_1AccountSharingInfoList(output.AccountSharingInfoList, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeDocumentResult = (output: any, context: __SerdeContext): DescribeDocumentResult => {
  return {
    Document:
      output.Document !== undefined && output.Document !== null
        ? deserializeAws_json1_1DocumentDescription(output.Document, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeEffectiveInstanceAssociationsResult = (
  output: any,
  context: __SerdeContext
): DescribeEffectiveInstanceAssociationsResult => {
  return {
    Associations:
      output.Associations !== undefined && output.Associations !== null
        ? deserializeAws_json1_1InstanceAssociationList(output.Associations, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeEffectivePatchesForPatchBaselineResult = (
  output: any,
  context: __SerdeContext
): DescribeEffectivePatchesForPatchBaselineResult => {
  return {
    EffectivePatches:
      output.EffectivePatches !== undefined && output.EffectivePatches !== null
        ? deserializeAws_json1_1EffectivePatchList(output.EffectivePatches, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeInstanceAssociationsStatusResult = (
  output: any,
  context: __SerdeContext
): DescribeInstanceAssociationsStatusResult => {
  return {
    InstanceAssociationStatusInfos:
      output.InstanceAssociationStatusInfos !== undefined && output.InstanceAssociationStatusInfos !== null
        ? deserializeAws_json1_1InstanceAssociationStatusInfos(output.InstanceAssociationStatusInfos, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeInstanceInformationResult = (
  output: any,
  context: __SerdeContext
): DescribeInstanceInformationResult => {
  return {
    InstanceInformationList:
      output.InstanceInformationList !== undefined && output.InstanceInformationList !== null
        ? deserializeAws_json1_1InstanceInformationList(output.InstanceInformationList, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeInstancePatchesResult = (
  output: any,
  context: __SerdeContext
): DescribeInstancePatchesResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Patches:
      output.Patches !== undefined && output.Patches !== null
        ? deserializeAws_json1_1PatchComplianceDataList(output.Patches, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeInstancePatchStatesForPatchGroupResult = (
  output: any,
  context: __SerdeContext
): DescribeInstancePatchStatesForPatchGroupResult => {
  return {
    InstancePatchStates:
      output.InstancePatchStates !== undefined && output.InstancePatchStates !== null
        ? deserializeAws_json1_1InstancePatchStatesList(output.InstancePatchStates, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeInstancePatchStatesResult = (
  output: any,
  context: __SerdeContext
): DescribeInstancePatchStatesResult => {
  return {
    InstancePatchStates:
      output.InstancePatchStates !== undefined && output.InstancePatchStates !== null
        ? deserializeAws_json1_1InstancePatchStateList(output.InstancePatchStates, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeInventoryDeletionsResult = (
  output: any,
  context: __SerdeContext
): DescribeInventoryDeletionsResult => {
  return {
    InventoryDeletions:
      output.InventoryDeletions !== undefined && output.InventoryDeletions !== null
        ? deserializeAws_json1_1InventoryDeletionsList(output.InventoryDeletions, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowExecutionsResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowExecutionsResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    WindowExecutions:
      output.WindowExecutions !== undefined && output.WindowExecutions !== null
        ? deserializeAws_json1_1MaintenanceWindowExecutionList(output.WindowExecutions, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowExecutionTaskInvocationsResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowExecutionTaskInvocationsResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    WindowExecutionTaskInvocationIdentities:
      output.WindowExecutionTaskInvocationIdentities !== undefined &&
      output.WindowExecutionTaskInvocationIdentities !== null
        ? deserializeAws_json1_1MaintenanceWindowExecutionTaskInvocationIdentityList(
            output.WindowExecutionTaskInvocationIdentities,
            context
          )
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowExecutionTasksResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowExecutionTasksResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    WindowExecutionTaskIdentities:
      output.WindowExecutionTaskIdentities !== undefined && output.WindowExecutionTaskIdentities !== null
        ? deserializeAws_json1_1MaintenanceWindowExecutionTaskIdentityList(
            output.WindowExecutionTaskIdentities,
            context
          )
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowScheduleResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowScheduleResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    ScheduledWindowExecutions:
      output.ScheduledWindowExecutions !== undefined && output.ScheduledWindowExecutions !== null
        ? deserializeAws_json1_1ScheduledWindowExecutionList(output.ScheduledWindowExecutions, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowsForTargetResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowsForTargetResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    WindowIdentities:
      output.WindowIdentities !== undefined && output.WindowIdentities !== null
        ? deserializeAws_json1_1MaintenanceWindowsForTargetList(output.WindowIdentities, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowsResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowsResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    WindowIdentities:
      output.WindowIdentities !== undefined && output.WindowIdentities !== null
        ? deserializeAws_json1_1MaintenanceWindowIdentityList(output.WindowIdentities, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowTargetsResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowTargetsResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1MaintenanceWindowTargetList(output.Targets, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeMaintenanceWindowTasksResult = (
  output: any,
  context: __SerdeContext
): DescribeMaintenanceWindowTasksResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Tasks:
      output.Tasks !== undefined && output.Tasks !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskList(output.Tasks, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeOpsItemsResponse = (
  output: any,
  context: __SerdeContext
): DescribeOpsItemsResponse => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    OpsItemSummaries:
      output.OpsItemSummaries !== undefined && output.OpsItemSummaries !== null
        ? deserializeAws_json1_1OpsItemSummaries(output.OpsItemSummaries, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeParametersResult = (
  output: any,
  context: __SerdeContext
): DescribeParametersResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1ParameterMetadataList(output.Parameters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribePatchBaselinesResult = (
  output: any,
  context: __SerdeContext
): DescribePatchBaselinesResult => {
  return {
    BaselineIdentities:
      output.BaselineIdentities !== undefined && output.BaselineIdentities !== null
        ? deserializeAws_json1_1PatchBaselineIdentityList(output.BaselineIdentities, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribePatchGroupsResult = (
  output: any,
  context: __SerdeContext
): DescribePatchGroupsResult => {
  return {
    Mappings:
      output.Mappings !== undefined && output.Mappings !== null
        ? deserializeAws_json1_1PatchGroupPatchBaselineMappingList(output.Mappings, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1DescribePatchGroupStateResult = (
  output: any,
  context: __SerdeContext
): DescribePatchGroupStateResult => {
  return {
    Instances: output.Instances !== undefined && output.Instances !== null ? output.Instances : undefined,
    InstancesWithFailedPatches:
      output.InstancesWithFailedPatches !== undefined && output.InstancesWithFailedPatches !== null
        ? output.InstancesWithFailedPatches
        : undefined,
    InstancesWithInstalledOtherPatches:
      output.InstancesWithInstalledOtherPatches !== undefined && output.InstancesWithInstalledOtherPatches !== null
        ? output.InstancesWithInstalledOtherPatches
        : undefined,
    InstancesWithInstalledPatches:
      output.InstancesWithInstalledPatches !== undefined && output.InstancesWithInstalledPatches !== null
        ? output.InstancesWithInstalledPatches
        : undefined,
    InstancesWithInstalledPendingRebootPatches:
      output.InstancesWithInstalledPendingRebootPatches !== undefined &&
      output.InstancesWithInstalledPendingRebootPatches !== null
        ? output.InstancesWithInstalledPendingRebootPatches
        : undefined,
    InstancesWithInstalledRejectedPatches:
      output.InstancesWithInstalledRejectedPatches !== undefined &&
      output.InstancesWithInstalledRejectedPatches !== null
        ? output.InstancesWithInstalledRejectedPatches
        : undefined,
    InstancesWithMissingPatches:
      output.InstancesWithMissingPatches !== undefined && output.InstancesWithMissingPatches !== null
        ? output.InstancesWithMissingPatches
        : undefined,
    InstancesWithNotApplicablePatches:
      output.InstancesWithNotApplicablePatches !== undefined && output.InstancesWithNotApplicablePatches !== null
        ? output.InstancesWithNotApplicablePatches
        : undefined,
    InstancesWithUnreportedNotApplicablePatches:
      output.InstancesWithUnreportedNotApplicablePatches !== undefined &&
      output.InstancesWithUnreportedNotApplicablePatches !== null
        ? output.InstancesWithUnreportedNotApplicablePatches
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribePatchPropertiesResult = (
  output: any,
  context: __SerdeContext
): DescribePatchPropertiesResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Properties:
      output.Properties !== undefined && output.Properties !== null
        ? deserializeAws_json1_1PatchPropertiesList(output.Properties, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DescribeSessionsResponse = (
  output: any,
  context: __SerdeContext
): DescribeSessionsResponse => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Sessions:
      output.Sessions !== undefined && output.Sessions !== null
        ? deserializeAws_json1_1SessionList(output.Sessions, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentAlreadyExists = (output: any, context: __SerdeContext): DocumentAlreadyExists => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentDefaultVersionDescription = (
  output: any,
  context: __SerdeContext
): DocumentDefaultVersionDescription => {
  return {
    DefaultVersion:
      output.DefaultVersion !== undefined && output.DefaultVersion !== null ? output.DefaultVersion : undefined,
    DefaultVersionName:
      output.DefaultVersionName !== undefined && output.DefaultVersionName !== null
        ? output.DefaultVersionName
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentDescription = (output: any, context: __SerdeContext): DocumentDescription => {
  return {
    AttachmentsInformation:
      output.AttachmentsInformation !== undefined && output.AttachmentsInformation !== null
        ? deserializeAws_json1_1AttachmentInformationList(output.AttachmentsInformation, context)
        : undefined,
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    DefaultVersion:
      output.DefaultVersion !== undefined && output.DefaultVersion !== null ? output.DefaultVersion : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    DocumentFormat:
      output.DocumentFormat !== undefined && output.DocumentFormat !== null ? output.DocumentFormat : undefined,
    DocumentType: output.DocumentType !== undefined && output.DocumentType !== null ? output.DocumentType : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    Hash: output.Hash !== undefined && output.Hash !== null ? output.Hash : undefined,
    HashType: output.HashType !== undefined && output.HashType !== null ? output.HashType : undefined,
    LatestVersion:
      output.LatestVersion !== undefined && output.LatestVersion !== null ? output.LatestVersion : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Owner: output.Owner !== undefined && output.Owner !== null ? output.Owner : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1DocumentParameterList(output.Parameters, context)
        : undefined,
    PlatformTypes:
      output.PlatformTypes !== undefined && output.PlatformTypes !== null
        ? deserializeAws_json1_1PlatformTypeList(output.PlatformTypes, context)
        : undefined,
    Requires:
      output.Requires !== undefined && output.Requires !== null
        ? deserializeAws_json1_1DocumentRequiresList(output.Requires, context)
        : undefined,
    SchemaVersion:
      output.SchemaVersion !== undefined && output.SchemaVersion !== null ? output.SchemaVersion : undefined,
    Sha1: output.Sha1 !== undefined && output.Sha1 !== null ? output.Sha1 : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusInformation:
      output.StatusInformation !== undefined && output.StatusInformation !== null
        ? output.StatusInformation
        : undefined,
    Tags:
      output.Tags !== undefined && output.Tags !== null
        ? deserializeAws_json1_1TagList(output.Tags, context)
        : undefined,
    TargetType: output.TargetType !== undefined && output.TargetType !== null ? output.TargetType : undefined,
    VersionName: output.VersionName !== undefined && output.VersionName !== null ? output.VersionName : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentIdentifier = (output: any, context: __SerdeContext): DocumentIdentifier => {
  return {
    DocumentFormat:
      output.DocumentFormat !== undefined && output.DocumentFormat !== null ? output.DocumentFormat : undefined,
    DocumentType: output.DocumentType !== undefined && output.DocumentType !== null ? output.DocumentType : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Owner: output.Owner !== undefined && output.Owner !== null ? output.Owner : undefined,
    PlatformTypes:
      output.PlatformTypes !== undefined && output.PlatformTypes !== null
        ? deserializeAws_json1_1PlatformTypeList(output.PlatformTypes, context)
        : undefined,
    Requires:
      output.Requires !== undefined && output.Requires !== null
        ? deserializeAws_json1_1DocumentRequiresList(output.Requires, context)
        : undefined,
    SchemaVersion:
      output.SchemaVersion !== undefined && output.SchemaVersion !== null ? output.SchemaVersion : undefined,
    Tags:
      output.Tags !== undefined && output.Tags !== null
        ? deserializeAws_json1_1TagList(output.Tags, context)
        : undefined,
    TargetType: output.TargetType !== undefined && output.TargetType !== null ? output.TargetType : undefined,
    VersionName: output.VersionName !== undefined && output.VersionName !== null ? output.VersionName : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentIdentifierList = (output: any, context: __SerdeContext): DocumentIdentifier[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1DocumentIdentifier(entry, context));
};

const deserializeAws_json1_1DocumentLimitExceeded = (output: any, context: __SerdeContext): DocumentLimitExceeded => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentParameter = (output: any, context: __SerdeContext): DocumentParameter => {
  return {
    DefaultValue: output.DefaultValue !== undefined && output.DefaultValue !== null ? output.DefaultValue : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentParameterList = (output: any, context: __SerdeContext): DocumentParameter[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1DocumentParameter(entry, context));
};

const deserializeAws_json1_1DocumentPermissionLimit = (
  output: any,
  context: __SerdeContext
): DocumentPermissionLimit => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentRequires = (output: any, context: __SerdeContext): DocumentRequires => {
  return {
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentRequiresList = (output: any, context: __SerdeContext): DocumentRequires[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1DocumentRequires(entry, context));
};

const deserializeAws_json1_1DocumentVersionInfo = (output: any, context: __SerdeContext): DocumentVersionInfo => {
  return {
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    DocumentFormat:
      output.DocumentFormat !== undefined && output.DocumentFormat !== null ? output.DocumentFormat : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    IsDefaultVersion:
      output.IsDefaultVersion !== undefined && output.IsDefaultVersion !== null ? output.IsDefaultVersion : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusInformation:
      output.StatusInformation !== undefined && output.StatusInformation !== null
        ? output.StatusInformation
        : undefined,
    VersionName: output.VersionName !== undefined && output.VersionName !== null ? output.VersionName : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentVersionLimitExceeded = (
  output: any,
  context: __SerdeContext
): DocumentVersionLimitExceeded => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DocumentVersionList = (output: any, context: __SerdeContext): DocumentVersionInfo[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1DocumentVersionInfo(entry, context));
};

const deserializeAws_json1_1DoesNotExistException = (output: any, context: __SerdeContext): DoesNotExistException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DuplicateDocumentContent = (
  output: any,
  context: __SerdeContext
): DuplicateDocumentContent => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DuplicateDocumentVersionName = (
  output: any,
  context: __SerdeContext
): DuplicateDocumentVersionName => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1DuplicateInstanceId = (output: any, context: __SerdeContext): DuplicateInstanceId => {
  return {} as any;
};

const deserializeAws_json1_1EffectivePatch = (output: any, context: __SerdeContext): EffectivePatch => {
  return {
    Patch:
      output.Patch !== undefined && output.Patch !== null
        ? deserializeAws_json1_1Patch(output.Patch, context)
        : undefined,
    PatchStatus:
      output.PatchStatus !== undefined && output.PatchStatus !== null
        ? deserializeAws_json1_1PatchStatus(output.PatchStatus, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1EffectivePatchList = (output: any, context: __SerdeContext): EffectivePatch[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1EffectivePatch(entry, context));
};

const deserializeAws_json1_1FailedCreateAssociation = (
  output: any,
  context: __SerdeContext
): FailedCreateAssociation => {
  return {
    Entry:
      output.Entry !== undefined && output.Entry !== null
        ? deserializeAws_json1_1CreateAssociationBatchRequestEntry(output.Entry, context)
        : undefined,
    Fault: output.Fault !== undefined && output.Fault !== null ? output.Fault : undefined,
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1FailedCreateAssociationList = (
  output: any,
  context: __SerdeContext
): FailedCreateAssociation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1FailedCreateAssociation(entry, context));
};

const deserializeAws_json1_1FailureDetails = (output: any, context: __SerdeContext): FailureDetails => {
  return {
    Details:
      output.Details !== undefined && output.Details !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.Details, context)
        : undefined,
    FailureStage: output.FailureStage !== undefined && output.FailureStage !== null ? output.FailureStage : undefined,
    FailureType: output.FailureType !== undefined && output.FailureType !== null ? output.FailureType : undefined,
  } as any;
};

const deserializeAws_json1_1FeatureNotAvailableException = (
  output: any,
  context: __SerdeContext
): FeatureNotAvailableException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1GetAutomationExecutionResult = (
  output: any,
  context: __SerdeContext
): GetAutomationExecutionResult => {
  return {
    AutomationExecution:
      output.AutomationExecution !== undefined && output.AutomationExecution !== null
        ? deserializeAws_json1_1AutomationExecution(output.AutomationExecution, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetCalendarStateResponse = (
  output: any,
  context: __SerdeContext
): GetCalendarStateResponse => {
  return {
    AtTime: output.AtTime !== undefined && output.AtTime !== null ? output.AtTime : undefined,
    NextTransitionTime:
      output.NextTransitionTime !== undefined && output.NextTransitionTime !== null
        ? output.NextTransitionTime
        : undefined,
    State: output.State !== undefined && output.State !== null ? output.State : undefined,
  } as any;
};

const deserializeAws_json1_1GetCommandInvocationResult = (
  output: any,
  context: __SerdeContext
): GetCommandInvocationResult => {
  return {
    CloudWatchOutputConfig:
      output.CloudWatchOutputConfig !== undefined && output.CloudWatchOutputConfig !== null
        ? deserializeAws_json1_1CloudWatchOutputConfig(output.CloudWatchOutputConfig, context)
        : undefined,
    CommandId: output.CommandId !== undefined && output.CommandId !== null ? output.CommandId : undefined,
    Comment: output.Comment !== undefined && output.Comment !== null ? output.Comment : undefined,
    DocumentName: output.DocumentName !== undefined && output.DocumentName !== null ? output.DocumentName : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    ExecutionElapsedTime:
      output.ExecutionElapsedTime !== undefined && output.ExecutionElapsedTime !== null
        ? output.ExecutionElapsedTime
        : undefined,
    ExecutionEndDateTime:
      output.ExecutionEndDateTime !== undefined && output.ExecutionEndDateTime !== null
        ? output.ExecutionEndDateTime
        : undefined,
    ExecutionStartDateTime:
      output.ExecutionStartDateTime !== undefined && output.ExecutionStartDateTime !== null
        ? output.ExecutionStartDateTime
        : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    PluginName: output.PluginName !== undefined && output.PluginName !== null ? output.PluginName : undefined,
    ResponseCode: output.ResponseCode !== undefined && output.ResponseCode !== null ? output.ResponseCode : undefined,
    StandardErrorContent:
      output.StandardErrorContent !== undefined && output.StandardErrorContent !== null
        ? output.StandardErrorContent
        : undefined,
    StandardErrorUrl:
      output.StandardErrorUrl !== undefined && output.StandardErrorUrl !== null ? output.StandardErrorUrl : undefined,
    StandardOutputContent:
      output.StandardOutputContent !== undefined && output.StandardOutputContent !== null
        ? output.StandardOutputContent
        : undefined,
    StandardOutputUrl:
      output.StandardOutputUrl !== undefined && output.StandardOutputUrl !== null
        ? output.StandardOutputUrl
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
  } as any;
};

const deserializeAws_json1_1GetConnectionStatusResponse = (
  output: any,
  context: __SerdeContext
): GetConnectionStatusResponse => {
  return {
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    Target: output.Target !== undefined && output.Target !== null ? output.Target : undefined,
  } as any;
};

const deserializeAws_json1_1GetDefaultPatchBaselineResult = (
  output: any,
  context: __SerdeContext
): GetDefaultPatchBaselineResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    OperatingSystem:
      output.OperatingSystem !== undefined && output.OperatingSystem !== null ? output.OperatingSystem : undefined,
  } as any;
};

const deserializeAws_json1_1GetDeployablePatchSnapshotForInstanceResult = (
  output: any,
  context: __SerdeContext
): GetDeployablePatchSnapshotForInstanceResult => {
  return {
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    Product: output.Product !== undefined && output.Product !== null ? output.Product : undefined,
    SnapshotDownloadUrl:
      output.SnapshotDownloadUrl !== undefined && output.SnapshotDownloadUrl !== null
        ? output.SnapshotDownloadUrl
        : undefined,
    SnapshotId: output.SnapshotId !== undefined && output.SnapshotId !== null ? output.SnapshotId : undefined,
  } as any;
};

const deserializeAws_json1_1GetDocumentResult = (output: any, context: __SerdeContext): GetDocumentResult => {
  return {
    AttachmentsContent:
      output.AttachmentsContent !== undefined && output.AttachmentsContent !== null
        ? deserializeAws_json1_1AttachmentContentList(output.AttachmentsContent, context)
        : undefined,
    Content: output.Content !== undefined && output.Content !== null ? output.Content : undefined,
    DocumentFormat:
      output.DocumentFormat !== undefined && output.DocumentFormat !== null ? output.DocumentFormat : undefined,
    DocumentType: output.DocumentType !== undefined && output.DocumentType !== null ? output.DocumentType : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Requires:
      output.Requires !== undefined && output.Requires !== null
        ? deserializeAws_json1_1DocumentRequiresList(output.Requires, context)
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusInformation:
      output.StatusInformation !== undefined && output.StatusInformation !== null
        ? output.StatusInformation
        : undefined,
    VersionName: output.VersionName !== undefined && output.VersionName !== null ? output.VersionName : undefined,
  } as any;
};

const deserializeAws_json1_1GetInventoryResult = (output: any, context: __SerdeContext): GetInventoryResult => {
  return {
    Entities:
      output.Entities !== undefined && output.Entities !== null
        ? deserializeAws_json1_1InventoryResultEntityList(output.Entities, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1GetInventorySchemaResult = (
  output: any,
  context: __SerdeContext
): GetInventorySchemaResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Schemas:
      output.Schemas !== undefined && output.Schemas !== null
        ? deserializeAws_json1_1InventoryItemSchemaResultList(output.Schemas, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetMaintenanceWindowExecutionResult = (
  output: any,
  context: __SerdeContext
): GetMaintenanceWindowExecutionResult => {
  return {
    EndTime:
      output.EndTime !== undefined && output.EndTime !== null ? new Date(Math.round(output.EndTime * 1000)) : undefined,
    StartTime:
      output.StartTime !== undefined && output.StartTime !== null
        ? new Date(Math.round(output.StartTime * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TaskIds:
      output.TaskIds !== undefined && output.TaskIds !== null
        ? deserializeAws_json1_1MaintenanceWindowExecutionTaskIdList(output.TaskIds, context)
        : undefined,
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetMaintenanceWindowExecutionTaskInvocationResult = (
  output: any,
  context: __SerdeContext
): GetMaintenanceWindowExecutionTaskInvocationResult => {
  return {
    EndTime:
      output.EndTime !== undefined && output.EndTime !== null ? new Date(Math.round(output.EndTime * 1000)) : undefined,
    ExecutionId: output.ExecutionId !== undefined && output.ExecutionId !== null ? output.ExecutionId : undefined,
    InvocationId: output.InvocationId !== undefined && output.InvocationId !== null ? output.InvocationId : undefined,
    OwnerInformation:
      output.OwnerInformation !== undefined && output.OwnerInformation !== null ? output.OwnerInformation : undefined,
    Parameters: output.Parameters !== undefined && output.Parameters !== null ? output.Parameters : undefined,
    StartTime:
      output.StartTime !== undefined && output.StartTime !== null
        ? new Date(Math.round(output.StartTime * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TaskExecutionId:
      output.TaskExecutionId !== undefined && output.TaskExecutionId !== null ? output.TaskExecutionId : undefined,
    TaskType: output.TaskType !== undefined && output.TaskType !== null ? output.TaskType : undefined,
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
    WindowTargetId:
      output.WindowTargetId !== undefined && output.WindowTargetId !== null ? output.WindowTargetId : undefined,
  } as any;
};

const deserializeAws_json1_1GetMaintenanceWindowExecutionTaskResult = (
  output: any,
  context: __SerdeContext
): GetMaintenanceWindowExecutionTaskResult => {
  return {
    EndTime:
      output.EndTime !== undefined && output.EndTime !== null ? new Date(Math.round(output.EndTime * 1000)) : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Priority: output.Priority !== undefined && output.Priority !== null ? output.Priority : undefined,
    ServiceRole: output.ServiceRole !== undefined && output.ServiceRole !== null ? output.ServiceRole : undefined,
    StartTime:
      output.StartTime !== undefined && output.StartTime !== null
        ? new Date(Math.round(output.StartTime * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TaskArn: output.TaskArn !== undefined && output.TaskArn !== null ? output.TaskArn : undefined,
    TaskExecutionId:
      output.TaskExecutionId !== undefined && output.TaskExecutionId !== null ? output.TaskExecutionId : undefined,
    TaskParameters:
      output.TaskParameters !== undefined && output.TaskParameters !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskParametersList(output.TaskParameters, context)
        : undefined,
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): GetMaintenanceWindowResult => {
  return {
    AllowUnassociatedTargets:
      output.AllowUnassociatedTargets !== undefined && output.AllowUnassociatedTargets !== null
        ? output.AllowUnassociatedTargets
        : undefined,
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    Cutoff: output.Cutoff !== undefined && output.Cutoff !== null ? output.Cutoff : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Duration: output.Duration !== undefined && output.Duration !== null ? output.Duration : undefined,
    Enabled: output.Enabled !== undefined && output.Enabled !== null ? output.Enabled : undefined,
    EndDate: output.EndDate !== undefined && output.EndDate !== null ? output.EndDate : undefined,
    ModifiedDate:
      output.ModifiedDate !== undefined && output.ModifiedDate !== null
        ? new Date(Math.round(output.ModifiedDate * 1000))
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    NextExecutionTime:
      output.NextExecutionTime !== undefined && output.NextExecutionTime !== null
        ? output.NextExecutionTime
        : undefined,
    Schedule: output.Schedule !== undefined && output.Schedule !== null ? output.Schedule : undefined,
    ScheduleOffset:
      output.ScheduleOffset !== undefined && output.ScheduleOffset !== null ? output.ScheduleOffset : undefined,
    ScheduleTimezone:
      output.ScheduleTimezone !== undefined && output.ScheduleTimezone !== null ? output.ScheduleTimezone : undefined,
    StartDate: output.StartDate !== undefined && output.StartDate !== null ? output.StartDate : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1GetMaintenanceWindowTaskResult = (
  output: any,
  context: __SerdeContext
): GetMaintenanceWindowTaskResult => {
  return {
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    LoggingInfo:
      output.LoggingInfo !== undefined && output.LoggingInfo !== null
        ? deserializeAws_json1_1LoggingInfo(output.LoggingInfo, context)
        : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Priority: output.Priority !== undefined && output.Priority !== null ? output.Priority : undefined,
    ServiceRoleArn:
      output.ServiceRoleArn !== undefined && output.ServiceRoleArn !== null ? output.ServiceRoleArn : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    TaskArn: output.TaskArn !== undefined && output.TaskArn !== null ? output.TaskArn : undefined,
    TaskInvocationParameters:
      output.TaskInvocationParameters !== undefined && output.TaskInvocationParameters !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskInvocationParameters(output.TaskInvocationParameters, context)
        : undefined,
    TaskParameters:
      output.TaskParameters !== undefined && output.TaskParameters !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskParameters(output.TaskParameters, context)
        : undefined,
    TaskType: output.TaskType !== undefined && output.TaskType !== null ? output.TaskType : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTaskId: output.WindowTaskId !== undefined && output.WindowTaskId !== null ? output.WindowTaskId : undefined,
  } as any;
};

const deserializeAws_json1_1GetOpsItemResponse = (output: any, context: __SerdeContext): GetOpsItemResponse => {
  return {
    OpsItem:
      output.OpsItem !== undefined && output.OpsItem !== null
        ? deserializeAws_json1_1OpsItem(output.OpsItem, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetOpsSummaryResult = (output: any, context: __SerdeContext): GetOpsSummaryResult => {
  return {
    Entities:
      output.Entities !== undefined && output.Entities !== null
        ? deserializeAws_json1_1OpsEntityList(output.Entities, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1GetParameterHistoryResult = (
  output: any,
  context: __SerdeContext
): GetParameterHistoryResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1ParameterHistoryList(output.Parameters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetParameterResult = (output: any, context: __SerdeContext): GetParameterResult => {
  return {
    Parameter:
      output.Parameter !== undefined && output.Parameter !== null
        ? deserializeAws_json1_1Parameter(output.Parameter, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetParametersByPathResult = (
  output: any,
  context: __SerdeContext
): GetParametersByPathResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1ParameterList(output.Parameters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetParametersResult = (output: any, context: __SerdeContext): GetParametersResult => {
  return {
    InvalidParameters:
      output.InvalidParameters !== undefined && output.InvalidParameters !== null
        ? deserializeAws_json1_1ParameterNameList(output.InvalidParameters, context)
        : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1ParameterList(output.Parameters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetPatchBaselineForPatchGroupResult = (
  output: any,
  context: __SerdeContext
): GetPatchBaselineForPatchGroupResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    OperatingSystem:
      output.OperatingSystem !== undefined && output.OperatingSystem !== null ? output.OperatingSystem : undefined,
    PatchGroup: output.PatchGroup !== undefined && output.PatchGroup !== null ? output.PatchGroup : undefined,
  } as any;
};

const deserializeAws_json1_1GetPatchBaselineResult = (output: any, context: __SerdeContext): GetPatchBaselineResult => {
  return {
    ApprovalRules:
      output.ApprovalRules !== undefined && output.ApprovalRules !== null
        ? deserializeAws_json1_1PatchRuleGroup(output.ApprovalRules, context)
        : undefined,
    ApprovedPatches:
      output.ApprovedPatches !== undefined && output.ApprovedPatches !== null
        ? deserializeAws_json1_1PatchIdList(output.ApprovedPatches, context)
        : undefined,
    ApprovedPatchesComplianceLevel:
      output.ApprovedPatchesComplianceLevel !== undefined && output.ApprovedPatchesComplianceLevel !== null
        ? output.ApprovedPatchesComplianceLevel
        : undefined,
    ApprovedPatchesEnableNonSecurity:
      output.ApprovedPatchesEnableNonSecurity !== undefined && output.ApprovedPatchesEnableNonSecurity !== null
        ? output.ApprovedPatchesEnableNonSecurity
        : undefined,
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    GlobalFilters:
      output.GlobalFilters !== undefined && output.GlobalFilters !== null
        ? deserializeAws_json1_1PatchFilterGroup(output.GlobalFilters, context)
        : undefined,
    ModifiedDate:
      output.ModifiedDate !== undefined && output.ModifiedDate !== null
        ? new Date(Math.round(output.ModifiedDate * 1000))
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OperatingSystem:
      output.OperatingSystem !== undefined && output.OperatingSystem !== null ? output.OperatingSystem : undefined,
    PatchGroups:
      output.PatchGroups !== undefined && output.PatchGroups !== null
        ? deserializeAws_json1_1PatchGroupList(output.PatchGroups, context)
        : undefined,
    RejectedPatches:
      output.RejectedPatches !== undefined && output.RejectedPatches !== null
        ? deserializeAws_json1_1PatchIdList(output.RejectedPatches, context)
        : undefined,
    RejectedPatchesAction:
      output.RejectedPatchesAction !== undefined && output.RejectedPatchesAction !== null
        ? output.RejectedPatchesAction
        : undefined,
    Sources:
      output.Sources !== undefined && output.Sources !== null
        ? deserializeAws_json1_1PatchSourceList(output.Sources, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1GetServiceSettingResult = (
  output: any,
  context: __SerdeContext
): GetServiceSettingResult => {
  return {
    ServiceSetting:
      output.ServiceSetting !== undefined && output.ServiceSetting !== null
        ? deserializeAws_json1_1ServiceSetting(output.ServiceSetting, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1HierarchyLevelLimitExceededException = (
  output: any,
  context: __SerdeContext
): HierarchyLevelLimitExceededException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1HierarchyTypeMismatchException = (
  output: any,
  context: __SerdeContext
): HierarchyTypeMismatchException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1IdempotentParameterMismatch = (
  output: any,
  context: __SerdeContext
): IdempotentParameterMismatch => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1IncompatiblePolicyException = (
  output: any,
  context: __SerdeContext
): IncompatiblePolicyException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceAggregatedAssociationOverview = (
  output: any,
  context: __SerdeContext
): InstanceAggregatedAssociationOverview => {
  return {
    DetailedStatus:
      output.DetailedStatus !== undefined && output.DetailedStatus !== null ? output.DetailedStatus : undefined,
    InstanceAssociationStatusAggregatedCount:
      output.InstanceAssociationStatusAggregatedCount !== undefined &&
      output.InstanceAssociationStatusAggregatedCount !== null
        ? deserializeAws_json1_1InstanceAssociationStatusAggregatedCount(
            output.InstanceAssociationStatusAggregatedCount,
            context
          )
        : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceAssociation = (output: any, context: __SerdeContext): InstanceAssociation => {
  return {
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    Content: output.Content !== undefined && output.Content !== null ? output.Content : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceAssociationList = (output: any, context: __SerdeContext): InstanceAssociation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InstanceAssociation(entry, context));
};

const deserializeAws_json1_1InstanceAssociationOutputLocation = (
  output: any,
  context: __SerdeContext
): InstanceAssociationOutputLocation => {
  return {
    S3Location:
      output.S3Location !== undefined && output.S3Location !== null
        ? deserializeAws_json1_1S3OutputLocation(output.S3Location, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceAssociationOutputUrl = (
  output: any,
  context: __SerdeContext
): InstanceAssociationOutputUrl => {
  return {
    S3OutputUrl:
      output.S3OutputUrl !== undefined && output.S3OutputUrl !== null
        ? deserializeAws_json1_1S3OutputUrl(output.S3OutputUrl, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceAssociationStatusAggregatedCount = (
  output: any,
  context: __SerdeContext
): { [key: string]: number } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: number }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1InstanceAssociationStatusInfo = (
  output: any,
  context: __SerdeContext
): InstanceAssociationStatusInfo => {
  return {
    AssociationId:
      output.AssociationId !== undefined && output.AssociationId !== null ? output.AssociationId : undefined,
    AssociationName:
      output.AssociationName !== undefined && output.AssociationName !== null ? output.AssociationName : undefined,
    AssociationVersion:
      output.AssociationVersion !== undefined && output.AssociationVersion !== null
        ? output.AssociationVersion
        : undefined,
    DetailedStatus:
      output.DetailedStatus !== undefined && output.DetailedStatus !== null ? output.DetailedStatus : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    ErrorCode: output.ErrorCode !== undefined && output.ErrorCode !== null ? output.ErrorCode : undefined,
    ExecutionDate:
      output.ExecutionDate !== undefined && output.ExecutionDate !== null
        ? new Date(Math.round(output.ExecutionDate * 1000))
        : undefined,
    ExecutionSummary:
      output.ExecutionSummary !== undefined && output.ExecutionSummary !== null ? output.ExecutionSummary : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OutputUrl:
      output.OutputUrl !== undefined && output.OutputUrl !== null
        ? deserializeAws_json1_1InstanceAssociationOutputUrl(output.OutputUrl, context)
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceAssociationStatusInfos = (
  output: any,
  context: __SerdeContext
): InstanceAssociationStatusInfo[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InstanceAssociationStatusInfo(entry, context));
};

const deserializeAws_json1_1InstanceIdList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1InstanceInformation = (output: any, context: __SerdeContext): InstanceInformation => {
  return {
    ActivationId: output.ActivationId !== undefined && output.ActivationId !== null ? output.ActivationId : undefined,
    AgentVersion: output.AgentVersion !== undefined && output.AgentVersion !== null ? output.AgentVersion : undefined,
    AssociationOverview:
      output.AssociationOverview !== undefined && output.AssociationOverview !== null
        ? deserializeAws_json1_1InstanceAggregatedAssociationOverview(output.AssociationOverview, context)
        : undefined,
    AssociationStatus:
      output.AssociationStatus !== undefined && output.AssociationStatus !== null
        ? output.AssociationStatus
        : undefined,
    ComputerName: output.ComputerName !== undefined && output.ComputerName !== null ? output.ComputerName : undefined,
    IPAddress: output.IPAddress !== undefined && output.IPAddress !== null ? output.IPAddress : undefined,
    IamRole: output.IamRole !== undefined && output.IamRole !== null ? output.IamRole : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    IsLatestVersion:
      output.IsLatestVersion !== undefined && output.IsLatestVersion !== null ? output.IsLatestVersion : undefined,
    LastAssociationExecutionDate:
      output.LastAssociationExecutionDate !== undefined && output.LastAssociationExecutionDate !== null
        ? new Date(Math.round(output.LastAssociationExecutionDate * 1000))
        : undefined,
    LastPingDateTime:
      output.LastPingDateTime !== undefined && output.LastPingDateTime !== null
        ? new Date(Math.round(output.LastPingDateTime * 1000))
        : undefined,
    LastSuccessfulAssociationExecutionDate:
      output.LastSuccessfulAssociationExecutionDate !== undefined &&
      output.LastSuccessfulAssociationExecutionDate !== null
        ? new Date(Math.round(output.LastSuccessfulAssociationExecutionDate * 1000))
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    PingStatus: output.PingStatus !== undefined && output.PingStatus !== null ? output.PingStatus : undefined,
    PlatformName: output.PlatformName !== undefined && output.PlatformName !== null ? output.PlatformName : undefined,
    PlatformType: output.PlatformType !== undefined && output.PlatformType !== null ? output.PlatformType : undefined,
    PlatformVersion:
      output.PlatformVersion !== undefined && output.PlatformVersion !== null ? output.PlatformVersion : undefined,
    RegistrationDate:
      output.RegistrationDate !== undefined && output.RegistrationDate !== null
        ? new Date(Math.round(output.RegistrationDate * 1000))
        : undefined,
    ResourceType: output.ResourceType !== undefined && output.ResourceType !== null ? output.ResourceType : undefined,
  } as any;
};

const deserializeAws_json1_1InstanceInformationList = (output: any, context: __SerdeContext): InstanceInformation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InstanceInformation(entry, context));
};

const deserializeAws_json1_1InstancePatchState = (output: any, context: __SerdeContext): InstancePatchState => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    FailedCount: output.FailedCount !== undefined && output.FailedCount !== null ? output.FailedCount : undefined,
    InstallOverrideList:
      output.InstallOverrideList !== undefined && output.InstallOverrideList !== null
        ? output.InstallOverrideList
        : undefined,
    InstalledCount:
      output.InstalledCount !== undefined && output.InstalledCount !== null ? output.InstalledCount : undefined,
    InstalledOtherCount:
      output.InstalledOtherCount !== undefined && output.InstalledOtherCount !== null
        ? output.InstalledOtherCount
        : undefined,
    InstalledPendingRebootCount:
      output.InstalledPendingRebootCount !== undefined && output.InstalledPendingRebootCount !== null
        ? output.InstalledPendingRebootCount
        : undefined,
    InstalledRejectedCount:
      output.InstalledRejectedCount !== undefined && output.InstalledRejectedCount !== null
        ? output.InstalledRejectedCount
        : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    LastNoRebootInstallOperationTime:
      output.LastNoRebootInstallOperationTime !== undefined && output.LastNoRebootInstallOperationTime !== null
        ? new Date(Math.round(output.LastNoRebootInstallOperationTime * 1000))
        : undefined,
    MissingCount: output.MissingCount !== undefined && output.MissingCount !== null ? output.MissingCount : undefined,
    NotApplicableCount:
      output.NotApplicableCount !== undefined && output.NotApplicableCount !== null
        ? output.NotApplicableCount
        : undefined,
    Operation: output.Operation !== undefined && output.Operation !== null ? output.Operation : undefined,
    OperationEndTime:
      output.OperationEndTime !== undefined && output.OperationEndTime !== null
        ? new Date(Math.round(output.OperationEndTime * 1000))
        : undefined,
    OperationStartTime:
      output.OperationStartTime !== undefined && output.OperationStartTime !== null
        ? new Date(Math.round(output.OperationStartTime * 1000))
        : undefined,
    OwnerInformation:
      output.OwnerInformation !== undefined && output.OwnerInformation !== null ? output.OwnerInformation : undefined,
    PatchGroup: output.PatchGroup !== undefined && output.PatchGroup !== null ? output.PatchGroup : undefined,
    RebootOption: output.RebootOption !== undefined && output.RebootOption !== null ? output.RebootOption : undefined,
    SnapshotId: output.SnapshotId !== undefined && output.SnapshotId !== null ? output.SnapshotId : undefined,
    UnreportedNotApplicableCount:
      output.UnreportedNotApplicableCount !== undefined && output.UnreportedNotApplicableCount !== null
        ? output.UnreportedNotApplicableCount
        : undefined,
  } as any;
};

const deserializeAws_json1_1InstancePatchStateList = (output: any, context: __SerdeContext): InstancePatchState[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InstancePatchState(entry, context));
};

const deserializeAws_json1_1InstancePatchStatesList = (output: any, context: __SerdeContext): InstancePatchState[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InstancePatchState(entry, context));
};

const deserializeAws_json1_1InternalServerError = (output: any, context: __SerdeContext): InternalServerError => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidActivation = (output: any, context: __SerdeContext): InvalidActivation => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidActivationId = (output: any, context: __SerdeContext): InvalidActivationId => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAggregatorException = (
  output: any,
  context: __SerdeContext
): InvalidAggregatorException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAllowedPatternException = (
  output: any,
  context: __SerdeContext
): InvalidAllowedPatternException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAssociation = (output: any, context: __SerdeContext): InvalidAssociation => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAssociationVersion = (
  output: any,
  context: __SerdeContext
): InvalidAssociationVersion => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAutomationExecutionParametersException = (
  output: any,
  context: __SerdeContext
): InvalidAutomationExecutionParametersException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAutomationSignalException = (
  output: any,
  context: __SerdeContext
): InvalidAutomationSignalException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidAutomationStatusUpdateException = (
  output: any,
  context: __SerdeContext
): InvalidAutomationStatusUpdateException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidCommandId = (output: any, context: __SerdeContext): InvalidCommandId => {
  return {} as any;
};

const deserializeAws_json1_1InvalidDeleteInventoryParametersException = (
  output: any,
  context: __SerdeContext
): InvalidDeleteInventoryParametersException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDeletionIdException = (
  output: any,
  context: __SerdeContext
): InvalidDeletionIdException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDocument = (output: any, context: __SerdeContext): InvalidDocument => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDocumentContent = (output: any, context: __SerdeContext): InvalidDocumentContent => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDocumentOperation = (
  output: any,
  context: __SerdeContext
): InvalidDocumentOperation => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDocumentSchemaVersion = (
  output: any,
  context: __SerdeContext
): InvalidDocumentSchemaVersion => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDocumentType = (output: any, context: __SerdeContext): InvalidDocumentType => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidDocumentVersion = (output: any, context: __SerdeContext): InvalidDocumentVersion => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidFilter = (output: any, context: __SerdeContext): InvalidFilter => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidFilterKey = (output: any, context: __SerdeContext): InvalidFilterKey => {
  return {} as any;
};

const deserializeAws_json1_1InvalidFilterOption = (output: any, context: __SerdeContext): InvalidFilterOption => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidFilterValue = (output: any, context: __SerdeContext): InvalidFilterValue => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidInstanceId = (output: any, context: __SerdeContext): InvalidInstanceId => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidInstanceInformationFilterValue = (
  output: any,
  context: __SerdeContext
): InvalidInstanceInformationFilterValue => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidInventoryGroupException = (
  output: any,
  context: __SerdeContext
): InvalidInventoryGroupException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidInventoryItemContextException = (
  output: any,
  context: __SerdeContext
): InvalidInventoryItemContextException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidInventoryRequestException = (
  output: any,
  context: __SerdeContext
): InvalidInventoryRequestException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidItemContentException = (
  output: any,
  context: __SerdeContext
): InvalidItemContentException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidKeyId = (output: any, context: __SerdeContext): InvalidKeyId => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidNextToken = (output: any, context: __SerdeContext): InvalidNextToken => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidNotificationConfig = (
  output: any,
  context: __SerdeContext
): InvalidNotificationConfig => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidOptionException = (output: any, context: __SerdeContext): InvalidOptionException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidOutputFolder = (output: any, context: __SerdeContext): InvalidOutputFolder => {
  return {} as any;
};

const deserializeAws_json1_1InvalidOutputLocation = (output: any, context: __SerdeContext): InvalidOutputLocation => {
  return {} as any;
};

const deserializeAws_json1_1InvalidParameters = (output: any, context: __SerdeContext): InvalidParameters => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidPermissionType = (output: any, context: __SerdeContext): InvalidPermissionType => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidPluginName = (output: any, context: __SerdeContext): InvalidPluginName => {
  return {} as any;
};

const deserializeAws_json1_1InvalidPolicyAttributeException = (
  output: any,
  context: __SerdeContext
): InvalidPolicyAttributeException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidPolicyTypeException = (
  output: any,
  context: __SerdeContext
): InvalidPolicyTypeException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidResourceId = (output: any, context: __SerdeContext): InvalidResourceId => {
  return {} as any;
};

const deserializeAws_json1_1InvalidResourceType = (output: any, context: __SerdeContext): InvalidResourceType => {
  return {} as any;
};

const deserializeAws_json1_1InvalidResultAttributeException = (
  output: any,
  context: __SerdeContext
): InvalidResultAttributeException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidRole = (output: any, context: __SerdeContext): InvalidRole => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidSchedule = (output: any, context: __SerdeContext): InvalidSchedule => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidTarget = (output: any, context: __SerdeContext): InvalidTarget => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidTypeNameException = (
  output: any,
  context: __SerdeContext
): InvalidTypeNameException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InvalidUpdate = (output: any, context: __SerdeContext): InvalidUpdate => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryDeletionsList = (
  output: any,
  context: __SerdeContext
): InventoryDeletionStatusItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InventoryDeletionStatusItem(entry, context));
};

const deserializeAws_json1_1InventoryDeletionStatusItem = (
  output: any,
  context: __SerdeContext
): InventoryDeletionStatusItem => {
  return {
    DeletionId: output.DeletionId !== undefined && output.DeletionId !== null ? output.DeletionId : undefined,
    DeletionStartTime:
      output.DeletionStartTime !== undefined && output.DeletionStartTime !== null
        ? new Date(Math.round(output.DeletionStartTime * 1000))
        : undefined,
    DeletionSummary:
      output.DeletionSummary !== undefined && output.DeletionSummary !== null
        ? deserializeAws_json1_1InventoryDeletionSummary(output.DeletionSummary, context)
        : undefined,
    LastStatus: output.LastStatus !== undefined && output.LastStatus !== null ? output.LastStatus : undefined,
    LastStatusMessage:
      output.LastStatusMessage !== undefined && output.LastStatusMessage !== null
        ? output.LastStatusMessage
        : undefined,
    LastStatusUpdateTime:
      output.LastStatusUpdateTime !== undefined && output.LastStatusUpdateTime !== null
        ? new Date(Math.round(output.LastStatusUpdateTime * 1000))
        : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryDeletionSummary = (
  output: any,
  context: __SerdeContext
): InventoryDeletionSummary => {
  return {
    RemainingCount:
      output.RemainingCount !== undefined && output.RemainingCount !== null ? output.RemainingCount : undefined,
    SummaryItems:
      output.SummaryItems !== undefined && output.SummaryItems !== null
        ? deserializeAws_json1_1InventoryDeletionSummaryItems(output.SummaryItems, context)
        : undefined,
    TotalCount: output.TotalCount !== undefined && output.TotalCount !== null ? output.TotalCount : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryDeletionSummaryItem = (
  output: any,
  context: __SerdeContext
): InventoryDeletionSummaryItem => {
  return {
    Count: output.Count !== undefined && output.Count !== null ? output.Count : undefined,
    RemainingCount:
      output.RemainingCount !== undefined && output.RemainingCount !== null ? output.RemainingCount : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryDeletionSummaryItems = (
  output: any,
  context: __SerdeContext
): InventoryDeletionSummaryItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InventoryDeletionSummaryItem(entry, context));
};

const deserializeAws_json1_1InventoryItemAttribute = (output: any, context: __SerdeContext): InventoryItemAttribute => {
  return {
    DataType: output.DataType !== undefined && output.DataType !== null ? output.DataType : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryItemAttributeList = (
  output: any,
  context: __SerdeContext
): InventoryItemAttribute[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InventoryItemAttribute(entry, context));
};

const deserializeAws_json1_1InventoryItemEntry = (output: any, context: __SerdeContext): { [key: string]: string } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1InventoryItemEntryList = (
  output: any,
  context: __SerdeContext
): { [key: string]: string }[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InventoryItemEntry(entry, context));
};

const deserializeAws_json1_1InventoryItemSchema = (output: any, context: __SerdeContext): InventoryItemSchema => {
  return {
    Attributes:
      output.Attributes !== undefined && output.Attributes !== null
        ? deserializeAws_json1_1InventoryItemAttributeList(output.Attributes, context)
        : undefined,
    DisplayName: output.DisplayName !== undefined && output.DisplayName !== null ? output.DisplayName : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryItemSchemaResultList = (
  output: any,
  context: __SerdeContext
): InventoryItemSchema[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InventoryItemSchema(entry, context));
};

const deserializeAws_json1_1InventoryResultEntity = (output: any, context: __SerdeContext): InventoryResultEntity => {
  return {
    Data:
      output.Data !== undefined && output.Data !== null
        ? deserializeAws_json1_1InventoryResultItemMap(output.Data, context)
        : undefined,
    Id: output.Id !== undefined && output.Id !== null ? output.Id : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryResultEntityList = (
  output: any,
  context: __SerdeContext
): InventoryResultEntity[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1InventoryResultEntity(entry, context));
};

const deserializeAws_json1_1InventoryResultItem = (output: any, context: __SerdeContext): InventoryResultItem => {
  return {
    CaptureTime: output.CaptureTime !== undefined && output.CaptureTime !== null ? output.CaptureTime : undefined,
    Content:
      output.Content !== undefined && output.Content !== null
        ? deserializeAws_json1_1InventoryItemEntryList(output.Content, context)
        : undefined,
    ContentHash: output.ContentHash !== undefined && output.ContentHash !== null ? output.ContentHash : undefined,
    SchemaVersion:
      output.SchemaVersion !== undefined && output.SchemaVersion !== null ? output.SchemaVersion : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1InventoryResultItemMap = (
  output: any,
  context: __SerdeContext
): { [key: string]: InventoryResultItem } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: InventoryResultItem }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1InventoryResultItem(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1InvocationDoesNotExist = (output: any, context: __SerdeContext): InvocationDoesNotExist => {
  return {} as any;
};

const deserializeAws_json1_1ItemContentMismatchException = (
  output: any,
  context: __SerdeContext
): ItemContentMismatchException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1ItemSizeLimitExceededException = (
  output: any,
  context: __SerdeContext
): ItemSizeLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1LabelParameterVersionResult = (
  output: any,
  context: __SerdeContext
): LabelParameterVersionResult => {
  return {
    InvalidLabels:
      output.InvalidLabels !== undefined && output.InvalidLabels !== null
        ? deserializeAws_json1_1ParameterLabelList(output.InvalidLabels, context)
        : undefined,
    ParameterVersion:
      output.ParameterVersion !== undefined && output.ParameterVersion !== null ? output.ParameterVersion : undefined,
  } as any;
};

const deserializeAws_json1_1ListAssociationsResult = (output: any, context: __SerdeContext): ListAssociationsResult => {
  return {
    Associations:
      output.Associations !== undefined && output.Associations !== null
        ? deserializeAws_json1_1AssociationList(output.Associations, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListAssociationVersionsResult = (
  output: any,
  context: __SerdeContext
): ListAssociationVersionsResult => {
  return {
    AssociationVersions:
      output.AssociationVersions !== undefined && output.AssociationVersions !== null
        ? deserializeAws_json1_1AssociationVersionList(output.AssociationVersions, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListCommandInvocationsResult = (
  output: any,
  context: __SerdeContext
): ListCommandInvocationsResult => {
  return {
    CommandInvocations:
      output.CommandInvocations !== undefined && output.CommandInvocations !== null
        ? deserializeAws_json1_1CommandInvocationList(output.CommandInvocations, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListCommandsResult = (output: any, context: __SerdeContext): ListCommandsResult => {
  return {
    Commands:
      output.Commands !== undefined && output.Commands !== null
        ? deserializeAws_json1_1CommandList(output.Commands, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListComplianceItemsResult = (
  output: any,
  context: __SerdeContext
): ListComplianceItemsResult => {
  return {
    ComplianceItems:
      output.ComplianceItems !== undefined && output.ComplianceItems !== null
        ? deserializeAws_json1_1ComplianceItemList(output.ComplianceItems, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListComplianceSummariesResult = (
  output: any,
  context: __SerdeContext
): ListComplianceSummariesResult => {
  return {
    ComplianceSummaryItems:
      output.ComplianceSummaryItems !== undefined && output.ComplianceSummaryItems !== null
        ? deserializeAws_json1_1ComplianceSummaryItemList(output.ComplianceSummaryItems, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListDocumentsResult = (output: any, context: __SerdeContext): ListDocumentsResult => {
  return {
    DocumentIdentifiers:
      output.DocumentIdentifiers !== undefined && output.DocumentIdentifiers !== null
        ? deserializeAws_json1_1DocumentIdentifierList(output.DocumentIdentifiers, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListDocumentVersionsResult = (
  output: any,
  context: __SerdeContext
): ListDocumentVersionsResult => {
  return {
    DocumentVersions:
      output.DocumentVersions !== undefined && output.DocumentVersions !== null
        ? deserializeAws_json1_1DocumentVersionList(output.DocumentVersions, context)
        : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
  } as any;
};

const deserializeAws_json1_1ListInventoryEntriesResult = (
  output: any,
  context: __SerdeContext
): ListInventoryEntriesResult => {
  return {
    CaptureTime: output.CaptureTime !== undefined && output.CaptureTime !== null ? output.CaptureTime : undefined,
    Entries:
      output.Entries !== undefined && output.Entries !== null
        ? deserializeAws_json1_1InventoryItemEntryList(output.Entries, context)
        : undefined,
    InstanceId: output.InstanceId !== undefined && output.InstanceId !== null ? output.InstanceId : undefined,
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    SchemaVersion:
      output.SchemaVersion !== undefined && output.SchemaVersion !== null ? output.SchemaVersion : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1ListResourceComplianceSummariesResult = (
  output: any,
  context: __SerdeContext
): ListResourceComplianceSummariesResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    ResourceComplianceSummaryItems:
      output.ResourceComplianceSummaryItems !== undefined && output.ResourceComplianceSummaryItems !== null
        ? deserializeAws_json1_1ResourceComplianceSummaryItemList(output.ResourceComplianceSummaryItems, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ListResourceDataSyncResult = (
  output: any,
  context: __SerdeContext
): ListResourceDataSyncResult => {
  return {
    NextToken: output.NextToken !== undefined && output.NextToken !== null ? output.NextToken : undefined,
    ResourceDataSyncItems:
      output.ResourceDataSyncItems !== undefined && output.ResourceDataSyncItems !== null
        ? deserializeAws_json1_1ResourceDataSyncItemList(output.ResourceDataSyncItems, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ListTagsForResourceResult = (
  output: any,
  context: __SerdeContext
): ListTagsForResourceResult => {
  return {
    TagList:
      output.TagList !== undefined && output.TagList !== null
        ? deserializeAws_json1_1TagList(output.TagList, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1LoggingInfo = (output: any, context: __SerdeContext): LoggingInfo => {
  return {
    S3BucketName: output.S3BucketName !== undefined && output.S3BucketName !== null ? output.S3BucketName : undefined,
    S3KeyPrefix: output.S3KeyPrefix !== undefined && output.S3KeyPrefix !== null ? output.S3KeyPrefix : undefined,
    S3Region: output.S3Region !== undefined && output.S3Region !== null ? output.S3Region : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowAutomationParameters = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowAutomationParameters => {
  return {
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.Parameters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowExecution = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowExecution => {
  return {
    EndTime:
      output.EndTime !== undefined && output.EndTime !== null ? new Date(Math.round(output.EndTime * 1000)) : undefined,
    StartTime:
      output.StartTime !== undefined && output.StartTime !== null
        ? new Date(Math.round(output.StartTime * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowExecutionList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowExecution[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1MaintenanceWindowExecution(entry, context));
};

const deserializeAws_json1_1MaintenanceWindowExecutionTaskIdentity = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowExecutionTaskIdentity => {
  return {
    EndTime:
      output.EndTime !== undefined && output.EndTime !== null ? new Date(Math.round(output.EndTime * 1000)) : undefined,
    StartTime:
      output.StartTime !== undefined && output.StartTime !== null
        ? new Date(Math.round(output.StartTime * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TaskArn: output.TaskArn !== undefined && output.TaskArn !== null ? output.TaskArn : undefined,
    TaskExecutionId:
      output.TaskExecutionId !== undefined && output.TaskExecutionId !== null ? output.TaskExecutionId : undefined,
    TaskType: output.TaskType !== undefined && output.TaskType !== null ? output.TaskType : undefined,
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowExecutionTaskIdentityList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowExecutionTaskIdentity[] => {
  return (output || []).map((entry: any) =>
    deserializeAws_json1_1MaintenanceWindowExecutionTaskIdentity(entry, context)
  );
};

const deserializeAws_json1_1MaintenanceWindowExecutionTaskIdList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1MaintenanceWindowExecutionTaskInvocationIdentity = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowExecutionTaskInvocationIdentity => {
  return {
    EndTime:
      output.EndTime !== undefined && output.EndTime !== null ? new Date(Math.round(output.EndTime * 1000)) : undefined,
    ExecutionId: output.ExecutionId !== undefined && output.ExecutionId !== null ? output.ExecutionId : undefined,
    InvocationId: output.InvocationId !== undefined && output.InvocationId !== null ? output.InvocationId : undefined,
    OwnerInformation:
      output.OwnerInformation !== undefined && output.OwnerInformation !== null ? output.OwnerInformation : undefined,
    Parameters: output.Parameters !== undefined && output.Parameters !== null ? output.Parameters : undefined,
    StartTime:
      output.StartTime !== undefined && output.StartTime !== null
        ? new Date(Math.round(output.StartTime * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    StatusDetails:
      output.StatusDetails !== undefined && output.StatusDetails !== null ? output.StatusDetails : undefined,
    TaskExecutionId:
      output.TaskExecutionId !== undefined && output.TaskExecutionId !== null ? output.TaskExecutionId : undefined,
    TaskType: output.TaskType !== undefined && output.TaskType !== null ? output.TaskType : undefined,
    WindowExecutionId:
      output.WindowExecutionId !== undefined && output.WindowExecutionId !== null
        ? output.WindowExecutionId
        : undefined,
    WindowTargetId:
      output.WindowTargetId !== undefined && output.WindowTargetId !== null ? output.WindowTargetId : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowExecutionTaskInvocationIdentityList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowExecutionTaskInvocationIdentity[] => {
  return (output || []).map((entry: any) =>
    deserializeAws_json1_1MaintenanceWindowExecutionTaskInvocationIdentity(entry, context)
  );
};

const deserializeAws_json1_1MaintenanceWindowIdentity = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowIdentity => {
  return {
    Cutoff: output.Cutoff !== undefined && output.Cutoff !== null ? output.Cutoff : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Duration: output.Duration !== undefined && output.Duration !== null ? output.Duration : undefined,
    Enabled: output.Enabled !== undefined && output.Enabled !== null ? output.Enabled : undefined,
    EndDate: output.EndDate !== undefined && output.EndDate !== null ? output.EndDate : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    NextExecutionTime:
      output.NextExecutionTime !== undefined && output.NextExecutionTime !== null
        ? output.NextExecutionTime
        : undefined,
    Schedule: output.Schedule !== undefined && output.Schedule !== null ? output.Schedule : undefined,
    ScheduleOffset:
      output.ScheduleOffset !== undefined && output.ScheduleOffset !== null ? output.ScheduleOffset : undefined,
    ScheduleTimezone:
      output.ScheduleTimezone !== undefined && output.ScheduleTimezone !== null ? output.ScheduleTimezone : undefined,
    StartDate: output.StartDate !== undefined && output.StartDate !== null ? output.StartDate : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowIdentityForTarget = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowIdentityForTarget => {
  return {
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowIdentityList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowIdentity[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1MaintenanceWindowIdentity(entry, context));
};

const deserializeAws_json1_1MaintenanceWindowLambdaParameters = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowLambdaParameters => {
  return {
    ClientContext:
      output.ClientContext !== undefined && output.ClientContext !== null ? output.ClientContext : undefined,
    Payload:
      output.Payload !== undefined && output.Payload !== null ? context.base64Decoder(output.Payload) : undefined,
    Qualifier: output.Qualifier !== undefined && output.Qualifier !== null ? output.Qualifier : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowRunCommandParameters = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowRunCommandParameters => {
  return {
    CloudWatchOutputConfig:
      output.CloudWatchOutputConfig !== undefined && output.CloudWatchOutputConfig !== null
        ? deserializeAws_json1_1CloudWatchOutputConfig(output.CloudWatchOutputConfig, context)
        : undefined,
    Comment: output.Comment !== undefined && output.Comment !== null ? output.Comment : undefined,
    DocumentHash: output.DocumentHash !== undefined && output.DocumentHash !== null ? output.DocumentHash : undefined,
    DocumentHashType:
      output.DocumentHashType !== undefined && output.DocumentHashType !== null ? output.DocumentHashType : undefined,
    DocumentVersion:
      output.DocumentVersion !== undefined && output.DocumentVersion !== null ? output.DocumentVersion : undefined,
    NotificationConfig:
      output.NotificationConfig !== undefined && output.NotificationConfig !== null
        ? deserializeAws_json1_1NotificationConfig(output.NotificationConfig, context)
        : undefined,
    OutputS3BucketName:
      output.OutputS3BucketName !== undefined && output.OutputS3BucketName !== null
        ? output.OutputS3BucketName
        : undefined,
    OutputS3KeyPrefix:
      output.OutputS3KeyPrefix !== undefined && output.OutputS3KeyPrefix !== null
        ? output.OutputS3KeyPrefix
        : undefined,
    Parameters:
      output.Parameters !== undefined && output.Parameters !== null
        ? deserializeAws_json1_1Parameters(output.Parameters, context)
        : undefined,
    ServiceRoleArn:
      output.ServiceRoleArn !== undefined && output.ServiceRoleArn !== null ? output.ServiceRoleArn : undefined,
    TimeoutSeconds:
      output.TimeoutSeconds !== undefined && output.TimeoutSeconds !== null ? output.TimeoutSeconds : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowsForTargetList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowIdentityForTarget[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1MaintenanceWindowIdentityForTarget(entry, context));
};

const deserializeAws_json1_1MaintenanceWindowStepFunctionsParameters = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowStepFunctionsParameters => {
  return {
    Input: output.Input !== undefined && output.Input !== null ? output.Input : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowTarget = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowTarget => {
  return {
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OwnerInformation:
      output.OwnerInformation !== undefined && output.OwnerInformation !== null ? output.OwnerInformation : undefined,
    ResourceType: output.ResourceType !== undefined && output.ResourceType !== null ? output.ResourceType : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTargetId:
      output.WindowTargetId !== undefined && output.WindowTargetId !== null ? output.WindowTargetId : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowTargetList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowTarget[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1MaintenanceWindowTarget(entry, context));
};

const deserializeAws_json1_1MaintenanceWindowTask = (output: any, context: __SerdeContext): MaintenanceWindowTask => {
  return {
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    LoggingInfo:
      output.LoggingInfo !== undefined && output.LoggingInfo !== null
        ? deserializeAws_json1_1LoggingInfo(output.LoggingInfo, context)
        : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Priority: output.Priority !== undefined && output.Priority !== null ? output.Priority : undefined,
    ServiceRoleArn:
      output.ServiceRoleArn !== undefined && output.ServiceRoleArn !== null ? output.ServiceRoleArn : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    TaskArn: output.TaskArn !== undefined && output.TaskArn !== null ? output.TaskArn : undefined,
    TaskParameters:
      output.TaskParameters !== undefined && output.TaskParameters !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskParameters(output.TaskParameters, context)
        : undefined,
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTaskId: output.WindowTaskId !== undefined && output.WindowTaskId !== null ? output.WindowTaskId : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowTaskInvocationParameters = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowTaskInvocationParameters => {
  return {
    Automation:
      output.Automation !== undefined && output.Automation !== null
        ? deserializeAws_json1_1MaintenanceWindowAutomationParameters(output.Automation, context)
        : undefined,
    Lambda:
      output.Lambda !== undefined && output.Lambda !== null
        ? deserializeAws_json1_1MaintenanceWindowLambdaParameters(output.Lambda, context)
        : undefined,
    RunCommand:
      output.RunCommand !== undefined && output.RunCommand !== null
        ? deserializeAws_json1_1MaintenanceWindowRunCommandParameters(output.RunCommand, context)
        : undefined,
    StepFunctions:
      output.StepFunctions !== undefined && output.StepFunctions !== null
        ? deserializeAws_json1_1MaintenanceWindowStepFunctionsParameters(output.StepFunctions, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowTaskList = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowTask[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1MaintenanceWindowTask(entry, context));
};

const deserializeAws_json1_1MaintenanceWindowTaskParameters = (
  output: any,
  context: __SerdeContext
): { [key: string]: MaintenanceWindowTaskParameterValueExpression } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: MaintenanceWindowTaskParameterValueExpression }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1MaintenanceWindowTaskParameterValueExpression(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1MaintenanceWindowTaskParametersList = (
  output: any,
  context: __SerdeContext
): { [key: string]: MaintenanceWindowTaskParameterValueExpression }[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1MaintenanceWindowTaskParameters(entry, context));
};

const deserializeAws_json1_1MaintenanceWindowTaskParameterValueExpression = (
  output: any,
  context: __SerdeContext
): MaintenanceWindowTaskParameterValueExpression => {
  return {
    Values:
      output.Values !== undefined && output.Values !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskParameterValueList(output.Values, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1MaintenanceWindowTaskParameterValueList = (
  output: any,
  context: __SerdeContext
): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1MaxDocumentSizeExceeded = (
  output: any,
  context: __SerdeContext
): MaxDocumentSizeExceeded => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1ModifyDocumentPermissionResponse = (
  output: any,
  context: __SerdeContext
): ModifyDocumentPermissionResponse => {
  return {} as any;
};

const deserializeAws_json1_1NonCompliantSummary = (output: any, context: __SerdeContext): NonCompliantSummary => {
  return {
    NonCompliantCount:
      output.NonCompliantCount !== undefined && output.NonCompliantCount !== null
        ? output.NonCompliantCount
        : undefined,
    SeveritySummary:
      output.SeveritySummary !== undefined && output.SeveritySummary !== null
        ? deserializeAws_json1_1SeveritySummary(output.SeveritySummary, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1NormalStringMap = (output: any, context: __SerdeContext): { [key: string]: string } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1NotificationConfig = (output: any, context: __SerdeContext): NotificationConfig => {
  return {
    NotificationArn:
      output.NotificationArn !== undefined && output.NotificationArn !== null ? output.NotificationArn : undefined,
    NotificationEvents:
      output.NotificationEvents !== undefined && output.NotificationEvents !== null
        ? deserializeAws_json1_1NotificationEventList(output.NotificationEvents, context)
        : undefined,
    NotificationType:
      output.NotificationType !== undefined && output.NotificationType !== null ? output.NotificationType : undefined,
  } as any;
};

const deserializeAws_json1_1NotificationEventList = (
  output: any,
  context: __SerdeContext
): (NotificationEvent | string)[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1OpsEntity = (output: any, context: __SerdeContext): OpsEntity => {
  return {
    Data:
      output.Data !== undefined && output.Data !== null
        ? deserializeAws_json1_1OpsEntityItemMap(output.Data, context)
        : undefined,
    Id: output.Id !== undefined && output.Id !== null ? output.Id : undefined,
  } as any;
};

const deserializeAws_json1_1OpsEntityItem = (output: any, context: __SerdeContext): OpsEntityItem => {
  return {
    CaptureTime: output.CaptureTime !== undefined && output.CaptureTime !== null ? output.CaptureTime : undefined,
    Content:
      output.Content !== undefined && output.Content !== null
        ? deserializeAws_json1_1OpsEntityItemEntryList(output.Content, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1OpsEntityItemEntry = (output: any, context: __SerdeContext): { [key: string]: string } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1OpsEntityItemEntryList = (
  output: any,
  context: __SerdeContext
): { [key: string]: string }[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1OpsEntityItemEntry(entry, context));
};

const deserializeAws_json1_1OpsEntityItemMap = (
  output: any,
  context: __SerdeContext
): { [key: string]: OpsEntityItem } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: OpsEntityItem }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1OpsEntityItem(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1OpsEntityList = (output: any, context: __SerdeContext): OpsEntity[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1OpsEntity(entry, context));
};

const deserializeAws_json1_1OpsItem = (output: any, context: __SerdeContext): OpsItem => {
  return {
    Category: output.Category !== undefined && output.Category !== null ? output.Category : undefined,
    CreatedBy: output.CreatedBy !== undefined && output.CreatedBy !== null ? output.CreatedBy : undefined,
    CreatedTime:
      output.CreatedTime !== undefined && output.CreatedTime !== null
        ? new Date(Math.round(output.CreatedTime * 1000))
        : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    LastModifiedBy:
      output.LastModifiedBy !== undefined && output.LastModifiedBy !== null ? output.LastModifiedBy : undefined,
    LastModifiedTime:
      output.LastModifiedTime !== undefined && output.LastModifiedTime !== null
        ? new Date(Math.round(output.LastModifiedTime * 1000))
        : undefined,
    Notifications:
      output.Notifications !== undefined && output.Notifications !== null
        ? deserializeAws_json1_1OpsItemNotifications(output.Notifications, context)
        : undefined,
    OperationalData:
      output.OperationalData !== undefined && output.OperationalData !== null
        ? deserializeAws_json1_1OpsItemOperationalData(output.OperationalData, context)
        : undefined,
    OpsItemId: output.OpsItemId !== undefined && output.OpsItemId !== null ? output.OpsItemId : undefined,
    Priority: output.Priority !== undefined && output.Priority !== null ? output.Priority : undefined,
    RelatedOpsItems:
      output.RelatedOpsItems !== undefined && output.RelatedOpsItems !== null
        ? deserializeAws_json1_1RelatedOpsItems(output.RelatedOpsItems, context)
        : undefined,
    Severity: output.Severity !== undefined && output.Severity !== null ? output.Severity : undefined,
    Source: output.Source !== undefined && output.Source !== null ? output.Source : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    Title: output.Title !== undefined && output.Title !== null ? output.Title : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemAlreadyExistsException = (
  output: any,
  context: __SerdeContext
): OpsItemAlreadyExistsException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    OpsItemId: output.OpsItemId !== undefined && output.OpsItemId !== null ? output.OpsItemId : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemDataValue = (output: any, context: __SerdeContext): OpsItemDataValue => {
  return {
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
    Value: output.Value !== undefined && output.Value !== null ? output.Value : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemInvalidParameterException = (
  output: any,
  context: __SerdeContext
): OpsItemInvalidParameterException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    ParameterNames:
      output.ParameterNames !== undefined && output.ParameterNames !== null
        ? deserializeAws_json1_1OpsItemParameterNamesList(output.ParameterNames, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemLimitExceededException = (
  output: any,
  context: __SerdeContext
): OpsItemLimitExceededException => {
  return {
    Limit: output.Limit !== undefined && output.Limit !== null ? output.Limit : undefined,
    LimitType: output.LimitType !== undefined && output.LimitType !== null ? output.LimitType : undefined,
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    ResourceTypes:
      output.ResourceTypes !== undefined && output.ResourceTypes !== null
        ? deserializeAws_json1_1OpsItemParameterNamesList(output.ResourceTypes, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemNotFoundException = (
  output: any,
  context: __SerdeContext
): OpsItemNotFoundException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemNotification = (output: any, context: __SerdeContext): OpsItemNotification => {
  return {
    Arn: output.Arn !== undefined && output.Arn !== null ? output.Arn : undefined,
  } as any;
};

const deserializeAws_json1_1OpsItemNotifications = (output: any, context: __SerdeContext): OpsItemNotification[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1OpsItemNotification(entry, context));
};

const deserializeAws_json1_1OpsItemOperationalData = (
  output: any,
  context: __SerdeContext
): { [key: string]: OpsItemDataValue } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: OpsItemDataValue }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1OpsItemDataValue(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1OpsItemParameterNamesList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1OpsItemSummaries = (output: any, context: __SerdeContext): OpsItemSummary[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1OpsItemSummary(entry, context));
};

const deserializeAws_json1_1OpsItemSummary = (output: any, context: __SerdeContext): OpsItemSummary => {
  return {
    Category: output.Category !== undefined && output.Category !== null ? output.Category : undefined,
    CreatedBy: output.CreatedBy !== undefined && output.CreatedBy !== null ? output.CreatedBy : undefined,
    CreatedTime:
      output.CreatedTime !== undefined && output.CreatedTime !== null
        ? new Date(Math.round(output.CreatedTime * 1000))
        : undefined,
    LastModifiedBy:
      output.LastModifiedBy !== undefined && output.LastModifiedBy !== null ? output.LastModifiedBy : undefined,
    LastModifiedTime:
      output.LastModifiedTime !== undefined && output.LastModifiedTime !== null
        ? new Date(Math.round(output.LastModifiedTime * 1000))
        : undefined,
    OperationalData:
      output.OperationalData !== undefined && output.OperationalData !== null
        ? deserializeAws_json1_1OpsItemOperationalData(output.OperationalData, context)
        : undefined,
    OpsItemId: output.OpsItemId !== undefined && output.OpsItemId !== null ? output.OpsItemId : undefined,
    Priority: output.Priority !== undefined && output.Priority !== null ? output.Priority : undefined,
    Severity: output.Severity !== undefined && output.Severity !== null ? output.Severity : undefined,
    Source: output.Source !== undefined && output.Source !== null ? output.Source : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    Title: output.Title !== undefined && output.Title !== null ? output.Title : undefined,
  } as any;
};

const deserializeAws_json1_1OutputSource = (output: any, context: __SerdeContext): OutputSource => {
  return {
    OutputSourceId:
      output.OutputSourceId !== undefined && output.OutputSourceId !== null ? output.OutputSourceId : undefined,
    OutputSourceType:
      output.OutputSourceType !== undefined && output.OutputSourceType !== null ? output.OutputSourceType : undefined,
  } as any;
};

const deserializeAws_json1_1Parameter = (output: any, context: __SerdeContext): Parameter => {
  return {
    ARN: output.ARN !== undefined && output.ARN !== null ? output.ARN : undefined,
    DataType: output.DataType !== undefined && output.DataType !== null ? output.DataType : undefined,
    LastModifiedDate:
      output.LastModifiedDate !== undefined && output.LastModifiedDate !== null
        ? new Date(Math.round(output.LastModifiedDate * 1000))
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Selector: output.Selector !== undefined && output.Selector !== null ? output.Selector : undefined,
    SourceResult: output.SourceResult !== undefined && output.SourceResult !== null ? output.SourceResult : undefined,
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
    Value: output.Value !== undefined && output.Value !== null ? output.Value : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterAlreadyExists = (output: any, context: __SerdeContext): ParameterAlreadyExists => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterHistory = (output: any, context: __SerdeContext): ParameterHistory => {
  return {
    AllowedPattern:
      output.AllowedPattern !== undefined && output.AllowedPattern !== null ? output.AllowedPattern : undefined,
    DataType: output.DataType !== undefined && output.DataType !== null ? output.DataType : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    KeyId: output.KeyId !== undefined && output.KeyId !== null ? output.KeyId : undefined,
    Labels:
      output.Labels !== undefined && output.Labels !== null
        ? deserializeAws_json1_1ParameterLabelList(output.Labels, context)
        : undefined,
    LastModifiedDate:
      output.LastModifiedDate !== undefined && output.LastModifiedDate !== null
        ? new Date(Math.round(output.LastModifiedDate * 1000))
        : undefined,
    LastModifiedUser:
      output.LastModifiedUser !== undefined && output.LastModifiedUser !== null ? output.LastModifiedUser : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Policies:
      output.Policies !== undefined && output.Policies !== null
        ? deserializeAws_json1_1ParameterPolicyList(output.Policies, context)
        : undefined,
    Tier: output.Tier !== undefined && output.Tier !== null ? output.Tier : undefined,
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
    Value: output.Value !== undefined && output.Value !== null ? output.Value : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterHistoryList = (output: any, context: __SerdeContext): ParameterHistory[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ParameterHistory(entry, context));
};

const deserializeAws_json1_1ParameterInlinePolicy = (output: any, context: __SerdeContext): ParameterInlinePolicy => {
  return {
    PolicyStatus: output.PolicyStatus !== undefined && output.PolicyStatus !== null ? output.PolicyStatus : undefined,
    PolicyText: output.PolicyText !== undefined && output.PolicyText !== null ? output.PolicyText : undefined,
    PolicyType: output.PolicyType !== undefined && output.PolicyType !== null ? output.PolicyType : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterLabelList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1ParameterLimitExceeded = (output: any, context: __SerdeContext): ParameterLimitExceeded => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterList = (output: any, context: __SerdeContext): Parameter[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Parameter(entry, context));
};

const deserializeAws_json1_1ParameterMaxVersionLimitExceeded = (
  output: any,
  context: __SerdeContext
): ParameterMaxVersionLimitExceeded => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterMetadata = (output: any, context: __SerdeContext): ParameterMetadata => {
  return {
    AllowedPattern:
      output.AllowedPattern !== undefined && output.AllowedPattern !== null ? output.AllowedPattern : undefined,
    DataType: output.DataType !== undefined && output.DataType !== null ? output.DataType : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    KeyId: output.KeyId !== undefined && output.KeyId !== null ? output.KeyId : undefined,
    LastModifiedDate:
      output.LastModifiedDate !== undefined && output.LastModifiedDate !== null
        ? new Date(Math.round(output.LastModifiedDate * 1000))
        : undefined,
    LastModifiedUser:
      output.LastModifiedUser !== undefined && output.LastModifiedUser !== null ? output.LastModifiedUser : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Policies:
      output.Policies !== undefined && output.Policies !== null
        ? deserializeAws_json1_1ParameterPolicyList(output.Policies, context)
        : undefined,
    Tier: output.Tier !== undefined && output.Tier !== null ? output.Tier : undefined,
    Type: output.Type !== undefined && output.Type !== null ? output.Type : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterMetadataList = (output: any, context: __SerdeContext): ParameterMetadata[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ParameterMetadata(entry, context));
};

const deserializeAws_json1_1ParameterNameList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1ParameterNotFound = (output: any, context: __SerdeContext): ParameterNotFound => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterPatternMismatchException = (
  output: any,
  context: __SerdeContext
): ParameterPatternMismatchException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterPolicyList = (output: any, context: __SerdeContext): ParameterInlinePolicy[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ParameterInlinePolicy(entry, context));
};

const deserializeAws_json1_1Parameters = (output: any, context: __SerdeContext): { [key: string]: string[] } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1ParameterValueList(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1ParameterValueList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1ParameterVersionLabelLimitExceeded = (
  output: any,
  context: __SerdeContext
): ParameterVersionLabelLimitExceeded => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ParameterVersionNotFound = (
  output: any,
  context: __SerdeContext
): ParameterVersionNotFound => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1Patch = (output: any, context: __SerdeContext): Patch => {
  return {
    Classification:
      output.Classification !== undefined && output.Classification !== null ? output.Classification : undefined,
    ContentUrl: output.ContentUrl !== undefined && output.ContentUrl !== null ? output.ContentUrl : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Id: output.Id !== undefined && output.Id !== null ? output.Id : undefined,
    KbNumber: output.KbNumber !== undefined && output.KbNumber !== null ? output.KbNumber : undefined,
    Language: output.Language !== undefined && output.Language !== null ? output.Language : undefined,
    MsrcNumber: output.MsrcNumber !== undefined && output.MsrcNumber !== null ? output.MsrcNumber : undefined,
    MsrcSeverity: output.MsrcSeverity !== undefined && output.MsrcSeverity !== null ? output.MsrcSeverity : undefined,
    Product: output.Product !== undefined && output.Product !== null ? output.Product : undefined,
    ProductFamily:
      output.ProductFamily !== undefined && output.ProductFamily !== null ? output.ProductFamily : undefined,
    ReleaseDate:
      output.ReleaseDate !== undefined && output.ReleaseDate !== null
        ? new Date(Math.round(output.ReleaseDate * 1000))
        : undefined,
    Title: output.Title !== undefined && output.Title !== null ? output.Title : undefined,
    Vendor: output.Vendor !== undefined && output.Vendor !== null ? output.Vendor : undefined,
  } as any;
};

const deserializeAws_json1_1PatchBaselineIdentity = (output: any, context: __SerdeContext): PatchBaselineIdentity => {
  return {
    BaselineDescription:
      output.BaselineDescription !== undefined && output.BaselineDescription !== null
        ? output.BaselineDescription
        : undefined,
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    BaselineName: output.BaselineName !== undefined && output.BaselineName !== null ? output.BaselineName : undefined,
    DefaultBaseline:
      output.DefaultBaseline !== undefined && output.DefaultBaseline !== null ? output.DefaultBaseline : undefined,
    OperatingSystem:
      output.OperatingSystem !== undefined && output.OperatingSystem !== null ? output.OperatingSystem : undefined,
  } as any;
};

const deserializeAws_json1_1PatchBaselineIdentityList = (
  output: any,
  context: __SerdeContext
): PatchBaselineIdentity[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchBaselineIdentity(entry, context));
};

const deserializeAws_json1_1PatchComplianceData = (output: any, context: __SerdeContext): PatchComplianceData => {
  return {
    Classification:
      output.Classification !== undefined && output.Classification !== null ? output.Classification : undefined,
    InstalledTime:
      output.InstalledTime !== undefined && output.InstalledTime !== null
        ? new Date(Math.round(output.InstalledTime * 1000))
        : undefined,
    KBId: output.KBId !== undefined && output.KBId !== null ? output.KBId : undefined,
    Severity: output.Severity !== undefined && output.Severity !== null ? output.Severity : undefined,
    State: output.State !== undefined && output.State !== null ? output.State : undefined,
    Title: output.Title !== undefined && output.Title !== null ? output.Title : undefined,
  } as any;
};

const deserializeAws_json1_1PatchComplianceDataList = (output: any, context: __SerdeContext): PatchComplianceData[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchComplianceData(entry, context));
};

const deserializeAws_json1_1PatchFilter = (output: any, context: __SerdeContext): PatchFilter => {
  return {
    Key: output.Key !== undefined && output.Key !== null ? output.Key : undefined,
    Values:
      output.Values !== undefined && output.Values !== null
        ? deserializeAws_json1_1PatchFilterValueList(output.Values, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1PatchFilterGroup = (output: any, context: __SerdeContext): PatchFilterGroup => {
  return {
    PatchFilters:
      output.PatchFilters !== undefined && output.PatchFilters !== null
        ? deserializeAws_json1_1PatchFilterList(output.PatchFilters, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1PatchFilterList = (output: any, context: __SerdeContext): PatchFilter[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchFilter(entry, context));
};

const deserializeAws_json1_1PatchFilterValueList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1PatchGroupList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1PatchGroupPatchBaselineMapping = (
  output: any,
  context: __SerdeContext
): PatchGroupPatchBaselineMapping => {
  return {
    BaselineIdentity:
      output.BaselineIdentity !== undefined && output.BaselineIdentity !== null
        ? deserializeAws_json1_1PatchBaselineIdentity(output.BaselineIdentity, context)
        : undefined,
    PatchGroup: output.PatchGroup !== undefined && output.PatchGroup !== null ? output.PatchGroup : undefined,
  } as any;
};

const deserializeAws_json1_1PatchGroupPatchBaselineMappingList = (
  output: any,
  context: __SerdeContext
): PatchGroupPatchBaselineMapping[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchGroupPatchBaselineMapping(entry, context));
};

const deserializeAws_json1_1PatchIdList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1PatchList = (output: any, context: __SerdeContext): Patch[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Patch(entry, context));
};

const deserializeAws_json1_1PatchPropertiesList = (
  output: any,
  context: __SerdeContext
): { [key: string]: string }[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchPropertyEntry(entry, context));
};

const deserializeAws_json1_1PatchPropertyEntry = (output: any, context: __SerdeContext): { [key: string]: string } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: value,
    }),
    {}
  );
};

const deserializeAws_json1_1PatchRule = (output: any, context: __SerdeContext): PatchRule => {
  return {
    ApproveAfterDays:
      output.ApproveAfterDays !== undefined && output.ApproveAfterDays !== null ? output.ApproveAfterDays : undefined,
    ApproveUntilDate:
      output.ApproveUntilDate !== undefined && output.ApproveUntilDate !== null ? output.ApproveUntilDate : undefined,
    ComplianceLevel:
      output.ComplianceLevel !== undefined && output.ComplianceLevel !== null ? output.ComplianceLevel : undefined,
    EnableNonSecurity:
      output.EnableNonSecurity !== undefined && output.EnableNonSecurity !== null
        ? output.EnableNonSecurity
        : undefined,
    PatchFilterGroup:
      output.PatchFilterGroup !== undefined && output.PatchFilterGroup !== null
        ? deserializeAws_json1_1PatchFilterGroup(output.PatchFilterGroup, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1PatchRuleGroup = (output: any, context: __SerdeContext): PatchRuleGroup => {
  return {
    PatchRules:
      output.PatchRules !== undefined && output.PatchRules !== null
        ? deserializeAws_json1_1PatchRuleList(output.PatchRules, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1PatchRuleList = (output: any, context: __SerdeContext): PatchRule[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchRule(entry, context));
};

const deserializeAws_json1_1PatchSource = (output: any, context: __SerdeContext): PatchSource => {
  return {
    Configuration:
      output.Configuration !== undefined && output.Configuration !== null ? output.Configuration : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Products:
      output.Products !== undefined && output.Products !== null
        ? deserializeAws_json1_1PatchSourceProductList(output.Products, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1PatchSourceList = (output: any, context: __SerdeContext): PatchSource[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1PatchSource(entry, context));
};

const deserializeAws_json1_1PatchSourceProductList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1PatchStatus = (output: any, context: __SerdeContext): PatchStatus => {
  return {
    ApprovalDate:
      output.ApprovalDate !== undefined && output.ApprovalDate !== null
        ? new Date(Math.round(output.ApprovalDate * 1000))
        : undefined,
    ComplianceLevel:
      output.ComplianceLevel !== undefined && output.ComplianceLevel !== null ? output.ComplianceLevel : undefined,
    DeploymentStatus:
      output.DeploymentStatus !== undefined && output.DeploymentStatus !== null ? output.DeploymentStatus : undefined,
  } as any;
};

const deserializeAws_json1_1PlatformTypeList = (output: any, context: __SerdeContext): (PlatformType | string)[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1PoliciesLimitExceededException = (
  output: any,
  context: __SerdeContext
): PoliciesLimitExceededException => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1ProgressCounters = (output: any, context: __SerdeContext): ProgressCounters => {
  return {
    CancelledSteps:
      output.CancelledSteps !== undefined && output.CancelledSteps !== null ? output.CancelledSteps : undefined,
    FailedSteps: output.FailedSteps !== undefined && output.FailedSteps !== null ? output.FailedSteps : undefined,
    SuccessSteps: output.SuccessSteps !== undefined && output.SuccessSteps !== null ? output.SuccessSteps : undefined,
    TimedOutSteps:
      output.TimedOutSteps !== undefined && output.TimedOutSteps !== null ? output.TimedOutSteps : undefined,
    TotalSteps: output.TotalSteps !== undefined && output.TotalSteps !== null ? output.TotalSteps : undefined,
  } as any;
};

const deserializeAws_json1_1PutComplianceItemsResult = (
  output: any,
  context: __SerdeContext
): PutComplianceItemsResult => {
  return {} as any;
};

const deserializeAws_json1_1PutInventoryResult = (output: any, context: __SerdeContext): PutInventoryResult => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1PutParameterResult = (output: any, context: __SerdeContext): PutParameterResult => {
  return {
    Tier: output.Tier !== undefined && output.Tier !== null ? output.Tier : undefined,
    Version: output.Version !== undefined && output.Version !== null ? output.Version : undefined,
  } as any;
};

const deserializeAws_json1_1Regions = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1RegisterDefaultPatchBaselineResult = (
  output: any,
  context: __SerdeContext
): RegisterDefaultPatchBaselineResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
  } as any;
};

const deserializeAws_json1_1RegisterPatchBaselineForPatchGroupResult = (
  output: any,
  context: __SerdeContext
): RegisterPatchBaselineForPatchGroupResult => {
  return {
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    PatchGroup: output.PatchGroup !== undefined && output.PatchGroup !== null ? output.PatchGroup : undefined,
  } as any;
};

const deserializeAws_json1_1RegisterTargetWithMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): RegisterTargetWithMaintenanceWindowResult => {
  return {
    WindowTargetId:
      output.WindowTargetId !== undefined && output.WindowTargetId !== null ? output.WindowTargetId : undefined,
  } as any;
};

const deserializeAws_json1_1RegisterTaskWithMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): RegisterTaskWithMaintenanceWindowResult => {
  return {
    WindowTaskId: output.WindowTaskId !== undefined && output.WindowTaskId !== null ? output.WindowTaskId : undefined,
  } as any;
};

const deserializeAws_json1_1RelatedOpsItem = (output: any, context: __SerdeContext): RelatedOpsItem => {
  return {
    OpsItemId: output.OpsItemId !== undefined && output.OpsItemId !== null ? output.OpsItemId : undefined,
  } as any;
};

const deserializeAws_json1_1RelatedOpsItems = (output: any, context: __SerdeContext): RelatedOpsItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1RelatedOpsItem(entry, context));
};

const deserializeAws_json1_1RemoveTagsFromResourceResult = (
  output: any,
  context: __SerdeContext
): RemoveTagsFromResourceResult => {
  return {} as any;
};

const deserializeAws_json1_1ResetServiceSettingResult = (
  output: any,
  context: __SerdeContext
): ResetServiceSettingResult => {
  return {
    ServiceSetting:
      output.ServiceSetting !== undefined && output.ServiceSetting !== null
        ? deserializeAws_json1_1ServiceSetting(output.ServiceSetting, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ResolvedTargets = (output: any, context: __SerdeContext): ResolvedTargets => {
  return {
    ParameterValues:
      output.ParameterValues !== undefined && output.ParameterValues !== null
        ? deserializeAws_json1_1TargetParameterList(output.ParameterValues, context)
        : undefined,
    Truncated: output.Truncated !== undefined && output.Truncated !== null ? output.Truncated : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceComplianceSummaryItem = (
  output: any,
  context: __SerdeContext
): ResourceComplianceSummaryItem => {
  return {
    ComplianceType:
      output.ComplianceType !== undefined && output.ComplianceType !== null ? output.ComplianceType : undefined,
    CompliantSummary:
      output.CompliantSummary !== undefined && output.CompliantSummary !== null
        ? deserializeAws_json1_1CompliantSummary(output.CompliantSummary, context)
        : undefined,
    ExecutionSummary:
      output.ExecutionSummary !== undefined && output.ExecutionSummary !== null
        ? deserializeAws_json1_1ComplianceExecutionSummary(output.ExecutionSummary, context)
        : undefined,
    NonCompliantSummary:
      output.NonCompliantSummary !== undefined && output.NonCompliantSummary !== null
        ? deserializeAws_json1_1NonCompliantSummary(output.NonCompliantSummary, context)
        : undefined,
    OverallSeverity:
      output.OverallSeverity !== undefined && output.OverallSeverity !== null ? output.OverallSeverity : undefined,
    ResourceId: output.ResourceId !== undefined && output.ResourceId !== null ? output.ResourceId : undefined,
    ResourceType: output.ResourceType !== undefined && output.ResourceType !== null ? output.ResourceType : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceComplianceSummaryItemList = (
  output: any,
  context: __SerdeContext
): ResourceComplianceSummaryItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ResourceComplianceSummaryItem(entry, context));
};

const deserializeAws_json1_1ResourceDataSyncAlreadyExistsException = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncAlreadyExistsException => {
  return {
    SyncName: output.SyncName !== undefined && output.SyncName !== null ? output.SyncName : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncAwsOrganizationsSource = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncAwsOrganizationsSource => {
  return {
    OrganizationSourceType:
      output.OrganizationSourceType !== undefined && output.OrganizationSourceType !== null
        ? output.OrganizationSourceType
        : undefined,
    OrganizationalUnits:
      output.OrganizationalUnits !== undefined && output.OrganizationalUnits !== null
        ? deserializeAws_json1_1ResourceDataSyncOrganizationalUnitList(output.OrganizationalUnits, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncConflictException = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncConflictException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncCountExceededException = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncCountExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncDestinationDataSharing = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncDestinationDataSharing => {
  return {
    DestinationDataSharingType:
      output.DestinationDataSharingType !== undefined && output.DestinationDataSharingType !== null
        ? output.DestinationDataSharingType
        : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncInvalidConfigurationException = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncInvalidConfigurationException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncItem = (output: any, context: __SerdeContext): ResourceDataSyncItem => {
  return {
    LastStatus: output.LastStatus !== undefined && output.LastStatus !== null ? output.LastStatus : undefined,
    LastSuccessfulSyncTime:
      output.LastSuccessfulSyncTime !== undefined && output.LastSuccessfulSyncTime !== null
        ? new Date(Math.round(output.LastSuccessfulSyncTime * 1000))
        : undefined,
    LastSyncStatusMessage:
      output.LastSyncStatusMessage !== undefined && output.LastSyncStatusMessage !== null
        ? output.LastSyncStatusMessage
        : undefined,
    LastSyncTime:
      output.LastSyncTime !== undefined && output.LastSyncTime !== null
        ? new Date(Math.round(output.LastSyncTime * 1000))
        : undefined,
    S3Destination:
      output.S3Destination !== undefined && output.S3Destination !== null
        ? deserializeAws_json1_1ResourceDataSyncS3Destination(output.S3Destination, context)
        : undefined,
    SyncCreatedTime:
      output.SyncCreatedTime !== undefined && output.SyncCreatedTime !== null
        ? new Date(Math.round(output.SyncCreatedTime * 1000))
        : undefined,
    SyncLastModifiedTime:
      output.SyncLastModifiedTime !== undefined && output.SyncLastModifiedTime !== null
        ? new Date(Math.round(output.SyncLastModifiedTime * 1000))
        : undefined,
    SyncName: output.SyncName !== undefined && output.SyncName !== null ? output.SyncName : undefined,
    SyncSource:
      output.SyncSource !== undefined && output.SyncSource !== null
        ? deserializeAws_json1_1ResourceDataSyncSourceWithState(output.SyncSource, context)
        : undefined,
    SyncType: output.SyncType !== undefined && output.SyncType !== null ? output.SyncType : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncItemList = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncItem[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ResourceDataSyncItem(entry, context));
};

const deserializeAws_json1_1ResourceDataSyncNotFoundException = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncNotFoundException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    SyncName: output.SyncName !== undefined && output.SyncName !== null ? output.SyncName : undefined,
    SyncType: output.SyncType !== undefined && output.SyncType !== null ? output.SyncType : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncOrganizationalUnit = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncOrganizationalUnit => {
  return {
    OrganizationalUnitId:
      output.OrganizationalUnitId !== undefined && output.OrganizationalUnitId !== null
        ? output.OrganizationalUnitId
        : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncOrganizationalUnitList = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncOrganizationalUnit[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ResourceDataSyncOrganizationalUnit(entry, context));
};

const deserializeAws_json1_1ResourceDataSyncS3Destination = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncS3Destination => {
  return {
    AWSKMSKeyARN: output.AWSKMSKeyARN !== undefined && output.AWSKMSKeyARN !== null ? output.AWSKMSKeyARN : undefined,
    BucketName: output.BucketName !== undefined && output.BucketName !== null ? output.BucketName : undefined,
    DestinationDataSharing:
      output.DestinationDataSharing !== undefined && output.DestinationDataSharing !== null
        ? deserializeAws_json1_1ResourceDataSyncDestinationDataSharing(output.DestinationDataSharing, context)
        : undefined,
    Prefix: output.Prefix !== undefined && output.Prefix !== null ? output.Prefix : undefined,
    Region: output.Region !== undefined && output.Region !== null ? output.Region : undefined,
    SyncFormat: output.SyncFormat !== undefined && output.SyncFormat !== null ? output.SyncFormat : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceDataSyncSourceRegionList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1ResourceDataSyncSourceWithState = (
  output: any,
  context: __SerdeContext
): ResourceDataSyncSourceWithState => {
  return {
    AwsOrganizationsSource:
      output.AwsOrganizationsSource !== undefined && output.AwsOrganizationsSource !== null
        ? deserializeAws_json1_1ResourceDataSyncAwsOrganizationsSource(output.AwsOrganizationsSource, context)
        : undefined,
    IncludeFutureRegions:
      output.IncludeFutureRegions !== undefined && output.IncludeFutureRegions !== null
        ? output.IncludeFutureRegions
        : undefined,
    SourceRegions:
      output.SourceRegions !== undefined && output.SourceRegions !== null
        ? deserializeAws_json1_1ResourceDataSyncSourceRegionList(output.SourceRegions, context)
        : undefined,
    SourceType: output.SourceType !== undefined && output.SourceType !== null ? output.SourceType : undefined,
    State: output.State !== undefined && output.State !== null ? output.State : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceInUseException = (output: any, context: __SerdeContext): ResourceInUseException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1ResourceLimitExceededException = (
  output: any,
  context: __SerdeContext
): ResourceLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1ResumeSessionResponse = (output: any, context: __SerdeContext): ResumeSessionResponse => {
  return {
    SessionId: output.SessionId !== undefined && output.SessionId !== null ? output.SessionId : undefined,
    StreamUrl: output.StreamUrl !== undefined && output.StreamUrl !== null ? output.StreamUrl : undefined,
    TokenValue: output.TokenValue !== undefined && output.TokenValue !== null ? output.TokenValue : undefined,
  } as any;
};

const deserializeAws_json1_1S3OutputLocation = (output: any, context: __SerdeContext): S3OutputLocation => {
  return {
    OutputS3BucketName:
      output.OutputS3BucketName !== undefined && output.OutputS3BucketName !== null
        ? output.OutputS3BucketName
        : undefined,
    OutputS3KeyPrefix:
      output.OutputS3KeyPrefix !== undefined && output.OutputS3KeyPrefix !== null
        ? output.OutputS3KeyPrefix
        : undefined,
    OutputS3Region:
      output.OutputS3Region !== undefined && output.OutputS3Region !== null ? output.OutputS3Region : undefined,
  } as any;
};

const deserializeAws_json1_1S3OutputUrl = (output: any, context: __SerdeContext): S3OutputUrl => {
  return {
    OutputUrl: output.OutputUrl !== undefined && output.OutputUrl !== null ? output.OutputUrl : undefined,
  } as any;
};

const deserializeAws_json1_1ScheduledWindowExecution = (
  output: any,
  context: __SerdeContext
): ScheduledWindowExecution => {
  return {
    ExecutionTime:
      output.ExecutionTime !== undefined && output.ExecutionTime !== null ? output.ExecutionTime : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1ScheduledWindowExecutionList = (
  output: any,
  context: __SerdeContext
): ScheduledWindowExecution[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1ScheduledWindowExecution(entry, context));
};

const deserializeAws_json1_1SendAutomationSignalResult = (
  output: any,
  context: __SerdeContext
): SendAutomationSignalResult => {
  return {} as any;
};

const deserializeAws_json1_1SendCommandResult = (output: any, context: __SerdeContext): SendCommandResult => {
  return {
    Command:
      output.Command !== undefined && output.Command !== null
        ? deserializeAws_json1_1Command(output.Command, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1ServiceSetting = (output: any, context: __SerdeContext): ServiceSetting => {
  return {
    ARN: output.ARN !== undefined && output.ARN !== null ? output.ARN : undefined,
    LastModifiedDate:
      output.LastModifiedDate !== undefined && output.LastModifiedDate !== null
        ? new Date(Math.round(output.LastModifiedDate * 1000))
        : undefined,
    LastModifiedUser:
      output.LastModifiedUser !== undefined && output.LastModifiedUser !== null ? output.LastModifiedUser : undefined,
    SettingId: output.SettingId !== undefined && output.SettingId !== null ? output.SettingId : undefined,
    SettingValue: output.SettingValue !== undefined && output.SettingValue !== null ? output.SettingValue : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
  } as any;
};

const deserializeAws_json1_1ServiceSettingNotFound = (output: any, context: __SerdeContext): ServiceSettingNotFound => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1Session = (output: any, context: __SerdeContext): Session => {
  return {
    Details: output.Details !== undefined && output.Details !== null ? output.Details : undefined,
    DocumentName: output.DocumentName !== undefined && output.DocumentName !== null ? output.DocumentName : undefined,
    EndDate:
      output.EndDate !== undefined && output.EndDate !== null ? new Date(Math.round(output.EndDate * 1000)) : undefined,
    OutputUrl:
      output.OutputUrl !== undefined && output.OutputUrl !== null
        ? deserializeAws_json1_1SessionManagerOutputUrl(output.OutputUrl, context)
        : undefined,
    Owner: output.Owner !== undefined && output.Owner !== null ? output.Owner : undefined,
    SessionId: output.SessionId !== undefined && output.SessionId !== null ? output.SessionId : undefined,
    StartDate:
      output.StartDate !== undefined && output.StartDate !== null
        ? new Date(Math.round(output.StartDate * 1000))
        : undefined,
    Status: output.Status !== undefined && output.Status !== null ? output.Status : undefined,
    Target: output.Target !== undefined && output.Target !== null ? output.Target : undefined,
  } as any;
};

const deserializeAws_json1_1SessionList = (output: any, context: __SerdeContext): Session[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Session(entry, context));
};

const deserializeAws_json1_1SessionManagerOutputUrl = (
  output: any,
  context: __SerdeContext
): SessionManagerOutputUrl => {
  return {
    CloudWatchOutputUrl:
      output.CloudWatchOutputUrl !== undefined && output.CloudWatchOutputUrl !== null
        ? output.CloudWatchOutputUrl
        : undefined,
    S3OutputUrl: output.S3OutputUrl !== undefined && output.S3OutputUrl !== null ? output.S3OutputUrl : undefined,
  } as any;
};

const deserializeAws_json1_1SeveritySummary = (output: any, context: __SerdeContext): SeveritySummary => {
  return {
    CriticalCount:
      output.CriticalCount !== undefined && output.CriticalCount !== null ? output.CriticalCount : undefined,
    HighCount: output.HighCount !== undefined && output.HighCount !== null ? output.HighCount : undefined,
    InformationalCount:
      output.InformationalCount !== undefined && output.InformationalCount !== null
        ? output.InformationalCount
        : undefined,
    LowCount: output.LowCount !== undefined && output.LowCount !== null ? output.LowCount : undefined,
    MediumCount: output.MediumCount !== undefined && output.MediumCount !== null ? output.MediumCount : undefined,
    UnspecifiedCount:
      output.UnspecifiedCount !== undefined && output.UnspecifiedCount !== null ? output.UnspecifiedCount : undefined,
  } as any;
};

const deserializeAws_json1_1StartAssociationsOnceResult = (
  output: any,
  context: __SerdeContext
): StartAssociationsOnceResult => {
  return {} as any;
};

const deserializeAws_json1_1StartAutomationExecutionResult = (
  output: any,
  context: __SerdeContext
): StartAutomationExecutionResult => {
  return {
    AutomationExecutionId:
      output.AutomationExecutionId !== undefined && output.AutomationExecutionId !== null
        ? output.AutomationExecutionId
        : undefined,
  } as any;
};

const deserializeAws_json1_1StartSessionResponse = (output: any, context: __SerdeContext): StartSessionResponse => {
  return {
    SessionId: output.SessionId !== undefined && output.SessionId !== null ? output.SessionId : undefined,
    StreamUrl: output.StreamUrl !== undefined && output.StreamUrl !== null ? output.StreamUrl : undefined,
    TokenValue: output.TokenValue !== undefined && output.TokenValue !== null ? output.TokenValue : undefined,
  } as any;
};

const deserializeAws_json1_1StatusUnchanged = (output: any, context: __SerdeContext): StatusUnchanged => {
  return {} as any;
};

const deserializeAws_json1_1StepExecution = (output: any, context: __SerdeContext): StepExecution => {
  return {
    Action: output.Action !== undefined && output.Action !== null ? output.Action : undefined,
    ExecutionEndTime:
      output.ExecutionEndTime !== undefined && output.ExecutionEndTime !== null
        ? new Date(Math.round(output.ExecutionEndTime * 1000))
        : undefined,
    ExecutionStartTime:
      output.ExecutionStartTime !== undefined && output.ExecutionStartTime !== null
        ? new Date(Math.round(output.ExecutionStartTime * 1000))
        : undefined,
    FailureDetails:
      output.FailureDetails !== undefined && output.FailureDetails !== null
        ? deserializeAws_json1_1FailureDetails(output.FailureDetails, context)
        : undefined,
    FailureMessage:
      output.FailureMessage !== undefined && output.FailureMessage !== null ? output.FailureMessage : undefined,
    Inputs:
      output.Inputs !== undefined && output.Inputs !== null
        ? deserializeAws_json1_1NormalStringMap(output.Inputs, context)
        : undefined,
    IsCritical: output.IsCritical !== undefined && output.IsCritical !== null ? output.IsCritical : undefined,
    IsEnd: output.IsEnd !== undefined && output.IsEnd !== null ? output.IsEnd : undefined,
    MaxAttempts: output.MaxAttempts !== undefined && output.MaxAttempts !== null ? output.MaxAttempts : undefined,
    NextStep: output.NextStep !== undefined && output.NextStep !== null ? output.NextStep : undefined,
    OnFailure: output.OnFailure !== undefined && output.OnFailure !== null ? output.OnFailure : undefined,
    Outputs:
      output.Outputs !== undefined && output.Outputs !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.Outputs, context)
        : undefined,
    OverriddenParameters:
      output.OverriddenParameters !== undefined && output.OverriddenParameters !== null
        ? deserializeAws_json1_1AutomationParameterMap(output.OverriddenParameters, context)
        : undefined,
    Response: output.Response !== undefined && output.Response !== null ? output.Response : undefined,
    ResponseCode: output.ResponseCode !== undefined && output.ResponseCode !== null ? output.ResponseCode : undefined,
    StepExecutionId:
      output.StepExecutionId !== undefined && output.StepExecutionId !== null ? output.StepExecutionId : undefined,
    StepName: output.StepName !== undefined && output.StepName !== null ? output.StepName : undefined,
    StepStatus: output.StepStatus !== undefined && output.StepStatus !== null ? output.StepStatus : undefined,
    TargetLocation:
      output.TargetLocation !== undefined && output.TargetLocation !== null
        ? deserializeAws_json1_1TargetLocation(output.TargetLocation, context)
        : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    TimeoutSeconds:
      output.TimeoutSeconds !== undefined && output.TimeoutSeconds !== null ? output.TimeoutSeconds : undefined,
    ValidNextSteps:
      output.ValidNextSteps !== undefined && output.ValidNextSteps !== null
        ? deserializeAws_json1_1ValidNextStepList(output.ValidNextSteps, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1StepExecutionList = (output: any, context: __SerdeContext): StepExecution[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1StepExecution(entry, context));
};

const deserializeAws_json1_1StopAutomationExecutionResult = (
  output: any,
  context: __SerdeContext
): StopAutomationExecutionResult => {
  return {} as any;
};

const deserializeAws_json1_1SubTypeCountLimitExceededException = (
  output: any,
  context: __SerdeContext
): SubTypeCountLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1Tag = (output: any, context: __SerdeContext): Tag => {
  return {
    Key: output.Key !== undefined && output.Key !== null ? output.Key : undefined,
    Value: output.Value !== undefined && output.Value !== null ? output.Value : undefined,
  } as any;
};

const deserializeAws_json1_1TagList = (output: any, context: __SerdeContext): Tag[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Tag(entry, context));
};

const deserializeAws_json1_1Target = (output: any, context: __SerdeContext): Target => {
  return {
    Key: output.Key !== undefined && output.Key !== null ? output.Key : undefined,
    Values:
      output.Values !== undefined && output.Values !== null
        ? deserializeAws_json1_1TargetValues(output.Values, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1TargetInUseException = (output: any, context: __SerdeContext): TargetInUseException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1TargetLocation = (output: any, context: __SerdeContext): TargetLocation => {
  return {
    Accounts:
      output.Accounts !== undefined && output.Accounts !== null
        ? deserializeAws_json1_1Accounts(output.Accounts, context)
        : undefined,
    ExecutionRoleName:
      output.ExecutionRoleName !== undefined && output.ExecutionRoleName !== null
        ? output.ExecutionRoleName
        : undefined,
    Regions:
      output.Regions !== undefined && output.Regions !== null
        ? deserializeAws_json1_1Regions(output.Regions, context)
        : undefined,
    TargetLocationMaxConcurrency:
      output.TargetLocationMaxConcurrency !== undefined && output.TargetLocationMaxConcurrency !== null
        ? output.TargetLocationMaxConcurrency
        : undefined,
    TargetLocationMaxErrors:
      output.TargetLocationMaxErrors !== undefined && output.TargetLocationMaxErrors !== null
        ? output.TargetLocationMaxErrors
        : undefined,
  } as any;
};

const deserializeAws_json1_1TargetLocations = (output: any, context: __SerdeContext): TargetLocation[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1TargetLocation(entry, context));
};

const deserializeAws_json1_1TargetMap = (output: any, context: __SerdeContext): { [key: string]: string[] } => {
  return Object.entries(output).reduce(
    (acc: { [key: string]: string[] }, [key, value]: [string, any]) => ({
      ...acc,
      [key]: deserializeAws_json1_1TargetMapValueList(value, context),
    }),
    {}
  );
};

const deserializeAws_json1_1TargetMaps = (output: any, context: __SerdeContext): { [key: string]: string[] }[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1TargetMap(entry, context));
};

const deserializeAws_json1_1TargetMapValueList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1TargetNotConnected = (output: any, context: __SerdeContext): TargetNotConnected => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1TargetParameterList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1Targets = (output: any, context: __SerdeContext): Target[] => {
  return (output || []).map((entry: any) => deserializeAws_json1_1Target(entry, context));
};

const deserializeAws_json1_1TargetValues = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeAws_json1_1TerminateSessionResponse = (
  output: any,
  context: __SerdeContext
): TerminateSessionResponse => {
  return {
    SessionId: output.SessionId !== undefined && output.SessionId !== null ? output.SessionId : undefined,
  } as any;
};

const deserializeAws_json1_1TooManyTagsError = (output: any, context: __SerdeContext): TooManyTagsError => {
  return {} as any;
};

const deserializeAws_json1_1TooManyUpdates = (output: any, context: __SerdeContext): TooManyUpdates => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1TotalSizeLimitExceededException = (
  output: any,
  context: __SerdeContext
): TotalSizeLimitExceededException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedCalendarException = (
  output: any,
  context: __SerdeContext
): UnsupportedCalendarException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedFeatureRequiredException = (
  output: any,
  context: __SerdeContext
): UnsupportedFeatureRequiredException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedInventoryItemContextException = (
  output: any,
  context: __SerdeContext
): UnsupportedInventoryItemContextException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
    TypeName: output.TypeName !== undefined && output.TypeName !== null ? output.TypeName : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedInventorySchemaVersionException = (
  output: any,
  context: __SerdeContext
): UnsupportedInventorySchemaVersionException => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedOperatingSystem = (
  output: any,
  context: __SerdeContext
): UnsupportedOperatingSystem => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedParameterType = (
  output: any,
  context: __SerdeContext
): UnsupportedParameterType => {
  return {
    message: output.message !== undefined && output.message !== null ? output.message : undefined,
  } as any;
};

const deserializeAws_json1_1UnsupportedPlatformType = (
  output: any,
  context: __SerdeContext
): UnsupportedPlatformType => {
  return {
    Message: output.Message !== undefined && output.Message !== null ? output.Message : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateAssociationResult = (
  output: any,
  context: __SerdeContext
): UpdateAssociationResult => {
  return {
    AssociationDescription:
      output.AssociationDescription !== undefined && output.AssociationDescription !== null
        ? deserializeAws_json1_1AssociationDescription(output.AssociationDescription, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateAssociationStatusResult = (
  output: any,
  context: __SerdeContext
): UpdateAssociationStatusResult => {
  return {
    AssociationDescription:
      output.AssociationDescription !== undefined && output.AssociationDescription !== null
        ? deserializeAws_json1_1AssociationDescription(output.AssociationDescription, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateDocumentDefaultVersionResult = (
  output: any,
  context: __SerdeContext
): UpdateDocumentDefaultVersionResult => {
  return {
    Description:
      output.Description !== undefined && output.Description !== null
        ? deserializeAws_json1_1DocumentDefaultVersionDescription(output.Description, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateDocumentResult = (output: any, context: __SerdeContext): UpdateDocumentResult => {
  return {
    DocumentDescription:
      output.DocumentDescription !== undefined && output.DocumentDescription !== null
        ? deserializeAws_json1_1DocumentDescription(output.DocumentDescription, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateMaintenanceWindowResult = (
  output: any,
  context: __SerdeContext
): UpdateMaintenanceWindowResult => {
  return {
    AllowUnassociatedTargets:
      output.AllowUnassociatedTargets !== undefined && output.AllowUnassociatedTargets !== null
        ? output.AllowUnassociatedTargets
        : undefined,
    Cutoff: output.Cutoff !== undefined && output.Cutoff !== null ? output.Cutoff : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Duration: output.Duration !== undefined && output.Duration !== null ? output.Duration : undefined,
    Enabled: output.Enabled !== undefined && output.Enabled !== null ? output.Enabled : undefined,
    EndDate: output.EndDate !== undefined && output.EndDate !== null ? output.EndDate : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Schedule: output.Schedule !== undefined && output.Schedule !== null ? output.Schedule : undefined,
    ScheduleOffset:
      output.ScheduleOffset !== undefined && output.ScheduleOffset !== null ? output.ScheduleOffset : undefined,
    ScheduleTimezone:
      output.ScheduleTimezone !== undefined && output.ScheduleTimezone !== null ? output.ScheduleTimezone : undefined,
    StartDate: output.StartDate !== undefined && output.StartDate !== null ? output.StartDate : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateMaintenanceWindowTargetResult = (
  output: any,
  context: __SerdeContext
): UpdateMaintenanceWindowTargetResult => {
  return {
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OwnerInformation:
      output.OwnerInformation !== undefined && output.OwnerInformation !== null ? output.OwnerInformation : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTargetId:
      output.WindowTargetId !== undefined && output.WindowTargetId !== null ? output.WindowTargetId : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateMaintenanceWindowTaskResult = (
  output: any,
  context: __SerdeContext
): UpdateMaintenanceWindowTaskResult => {
  return {
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    LoggingInfo:
      output.LoggingInfo !== undefined && output.LoggingInfo !== null
        ? deserializeAws_json1_1LoggingInfo(output.LoggingInfo, context)
        : undefined,
    MaxConcurrency:
      output.MaxConcurrency !== undefined && output.MaxConcurrency !== null ? output.MaxConcurrency : undefined,
    MaxErrors: output.MaxErrors !== undefined && output.MaxErrors !== null ? output.MaxErrors : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    Priority: output.Priority !== undefined && output.Priority !== null ? output.Priority : undefined,
    ServiceRoleArn:
      output.ServiceRoleArn !== undefined && output.ServiceRoleArn !== null ? output.ServiceRoleArn : undefined,
    Targets:
      output.Targets !== undefined && output.Targets !== null
        ? deserializeAws_json1_1Targets(output.Targets, context)
        : undefined,
    TaskArn: output.TaskArn !== undefined && output.TaskArn !== null ? output.TaskArn : undefined,
    TaskInvocationParameters:
      output.TaskInvocationParameters !== undefined && output.TaskInvocationParameters !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskInvocationParameters(output.TaskInvocationParameters, context)
        : undefined,
    TaskParameters:
      output.TaskParameters !== undefined && output.TaskParameters !== null
        ? deserializeAws_json1_1MaintenanceWindowTaskParameters(output.TaskParameters, context)
        : undefined,
    WindowId: output.WindowId !== undefined && output.WindowId !== null ? output.WindowId : undefined,
    WindowTaskId: output.WindowTaskId !== undefined && output.WindowTaskId !== null ? output.WindowTaskId : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateManagedInstanceRoleResult = (
  output: any,
  context: __SerdeContext
): UpdateManagedInstanceRoleResult => {
  return {} as any;
};

const deserializeAws_json1_1UpdateOpsItemResponse = (output: any, context: __SerdeContext): UpdateOpsItemResponse => {
  return {} as any;
};

const deserializeAws_json1_1UpdatePatchBaselineResult = (
  output: any,
  context: __SerdeContext
): UpdatePatchBaselineResult => {
  return {
    ApprovalRules:
      output.ApprovalRules !== undefined && output.ApprovalRules !== null
        ? deserializeAws_json1_1PatchRuleGroup(output.ApprovalRules, context)
        : undefined,
    ApprovedPatches:
      output.ApprovedPatches !== undefined && output.ApprovedPatches !== null
        ? deserializeAws_json1_1PatchIdList(output.ApprovedPatches, context)
        : undefined,
    ApprovedPatchesComplianceLevel:
      output.ApprovedPatchesComplianceLevel !== undefined && output.ApprovedPatchesComplianceLevel !== null
        ? output.ApprovedPatchesComplianceLevel
        : undefined,
    ApprovedPatchesEnableNonSecurity:
      output.ApprovedPatchesEnableNonSecurity !== undefined && output.ApprovedPatchesEnableNonSecurity !== null
        ? output.ApprovedPatchesEnableNonSecurity
        : undefined,
    BaselineId: output.BaselineId !== undefined && output.BaselineId !== null ? output.BaselineId : undefined,
    CreatedDate:
      output.CreatedDate !== undefined && output.CreatedDate !== null
        ? new Date(Math.round(output.CreatedDate * 1000))
        : undefined,
    Description: output.Description !== undefined && output.Description !== null ? output.Description : undefined,
    GlobalFilters:
      output.GlobalFilters !== undefined && output.GlobalFilters !== null
        ? deserializeAws_json1_1PatchFilterGroup(output.GlobalFilters, context)
        : undefined,
    ModifiedDate:
      output.ModifiedDate !== undefined && output.ModifiedDate !== null
        ? new Date(Math.round(output.ModifiedDate * 1000))
        : undefined,
    Name: output.Name !== undefined && output.Name !== null ? output.Name : undefined,
    OperatingSystem:
      output.OperatingSystem !== undefined && output.OperatingSystem !== null ? output.OperatingSystem : undefined,
    RejectedPatches:
      output.RejectedPatches !== undefined && output.RejectedPatches !== null
        ? deserializeAws_json1_1PatchIdList(output.RejectedPatches, context)
        : undefined,
    RejectedPatchesAction:
      output.RejectedPatchesAction !== undefined && output.RejectedPatchesAction !== null
        ? output.RejectedPatchesAction
        : undefined,
    Sources:
      output.Sources !== undefined && output.Sources !== null
        ? deserializeAws_json1_1PatchSourceList(output.Sources, context)
        : undefined,
  } as any;
};

const deserializeAws_json1_1UpdateResourceDataSyncResult = (
  output: any,
  context: __SerdeContext
): UpdateResourceDataSyncResult => {
  return {} as any;
};

const deserializeAws_json1_1UpdateServiceSettingResult = (
  output: any,
  context: __SerdeContext
): UpdateServiceSettingResult => {
  return {} as any;
};

const deserializeAws_json1_1ValidNextStepList = (output: any, context: __SerdeContext): string[] => {
  return (output || []).map((entry: any) => entry);
};

const deserializeMetadata = (output: __HttpResponse): __ResponseMetadata => ({
  httpStatusCode: output.statusCode,
  httpHeaders: output.headers,
  requestId: output.headers["x-amzn-requestid"],
});

// Collect low-level response body stream to Uint8Array.
const collectBody = (streamBody: any = new Uint8Array(), context: __SerdeContext): Promise<Uint8Array> => {
  if (streamBody instanceof Uint8Array) {
    return Promise.resolve(streamBody);
  }
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
};

// Encode Uint8Array data into string with utf-8.
const collectBodyString = (streamBody: any, context: __SerdeContext): Promise<string> =>
  collectBody(streamBody, context).then((body) => context.utf8Encoder(body));

const buildHttpRpcRequest = async (
  context: __SerdeContext,
  headers: __HeaderBag,
  path: string,
  resolvedHostname: string | undefined,
  body: any
): Promise<__HttpRequest> => {
  const { hostname, protocol = "https", port } = await context.endpoint();
  const contents: any = {
    protocol,
    hostname,
    port,
    method: "POST",
    path,
    headers,
  };
  if (resolvedHostname !== undefined) {
    contents.hostname = resolvedHostname;
  }
  if (body !== undefined) {
    contents.body = body;
  }
  return new __HttpRequest(contents);
};

const parseBody = (streamBody: any, context: __SerdeContext): any =>
  collectBodyString(streamBody, context).then((encoded) => {
    if (encoded.length) {
      return JSON.parse(encoded);
    }
    return {};
  });