@aws-sdk/client-ssm 3.34.0 → 3.37.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,3746 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccountSharingInfo {
+    
+    AccountId?: string;
+    
+    SharedDocumentVersion?: string;
+}
+export declare namespace AccountSharingInfo {
+    
+    const filterSensitiveLog: (obj: AccountSharingInfo) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface Activation {
+    
+    ActivationId?: string;
+    
+    Description?: string;
+    
+    DefaultInstanceName?: string;
+    
+    IamRole?: string;
+    
+    RegistrationLimit?: number;
+    
+    RegistrationsCount?: number;
+    
+    ExpirationDate?: Date;
+    
+    Expired?: boolean;
+    
+    CreatedDate?: Date;
+    
+    Tags?: Tag[];
+}
+export declare namespace Activation {
+    
+    const filterSensitiveLog: (obj: Activation) => any;
+}
+export declare enum ResourceTypeForTagging {
+    DOCUMENT = "Document",
+    MAINTENANCE_WINDOW = "MaintenanceWindow",
+    MANAGED_INSTANCE = "ManagedInstance",
+    OPSMETADATA = "OpsMetadata",
+    OPS_ITEM = "OpsItem",
+    PARAMETER = "Parameter",
+    PATCH_BASELINE = "PatchBaseline"
+}
+export interface AddTagsToResourceRequest {
+    
+    ResourceType: ResourceTypeForTagging | string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace AddTagsToResourceRequest {
+    
+    const filterSensitiveLog: (obj: AddTagsToResourceRequest) => any;
+}
+export interface AddTagsToResourceResult {
+}
+export declare namespace AddTagsToResourceResult {
+    
+    const filterSensitiveLog: (obj: AddTagsToResourceResult) => any;
+}
+
+export interface InternalServerError extends __SmithyException, $MetadataBearer {
+    name: "InternalServerError";
+    $fault: "server";
+    Message?: string;
+}
+export declare namespace InternalServerError {
+    
+    const filterSensitiveLog: (obj: InternalServerError) => any;
+}
+
+export interface InvalidResourceId extends __SmithyException, $MetadataBearer {
+    name: "InvalidResourceId";
+    $fault: "client";
+}
+export declare namespace InvalidResourceId {
+    
+    const filterSensitiveLog: (obj: InvalidResourceId) => any;
+}
+
+export interface InvalidResourceType extends __SmithyException, $MetadataBearer {
+    name: "InvalidResourceType";
+    $fault: "client";
+}
+export declare namespace InvalidResourceType {
+    
+    const filterSensitiveLog: (obj: InvalidResourceType) => any;
+}
+
+export interface TooManyTagsError extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsError";
+    $fault: "client";
+}
+export declare namespace TooManyTagsError {
+    
+    const filterSensitiveLog: (obj: TooManyTagsError) => any;
+}
+
+export interface TooManyUpdates extends __SmithyException, $MetadataBearer {
+    name: "TooManyUpdates";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TooManyUpdates {
+    
+    const filterSensitiveLog: (obj: TooManyUpdates) => any;
+}
+
+export interface AlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "AlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: AlreadyExistsException) => any;
+}
+export interface AssociateOpsItemRelatedItemRequest {
+    
+    OpsItemId: string | undefined;
+    
+    AssociationType: string | undefined;
+    
+    ResourceType: string | undefined;
+    
+    ResourceUri: string | undefined;
+}
+export declare namespace AssociateOpsItemRelatedItemRequest {
+    
+    const filterSensitiveLog: (obj: AssociateOpsItemRelatedItemRequest) => any;
+}
+export interface AssociateOpsItemRelatedItemResponse {
+    
+    AssociationId?: string;
+}
+export declare namespace AssociateOpsItemRelatedItemResponse {
+    
+    const filterSensitiveLog: (obj: AssociateOpsItemRelatedItemResponse) => any;
+}
+
+export interface OpsItemInvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "OpsItemInvalidParameterException";
+    $fault: "client";
+    ParameterNames?: string[];
+    Message?: string;
+}
+export declare namespace OpsItemInvalidParameterException {
+    
+    const filterSensitiveLog: (obj: OpsItemInvalidParameterException) => any;
+}
+
+export interface OpsItemLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "OpsItemLimitExceededException";
+    $fault: "client";
+    ResourceTypes?: string[];
+    Limit?: number;
+    LimitType?: string;
+    Message?: string;
+}
+export declare namespace OpsItemLimitExceededException {
+    
+    const filterSensitiveLog: (obj: OpsItemLimitExceededException) => any;
+}
+
+export interface OpsItemNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "OpsItemNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace OpsItemNotFoundException {
+    
+    const filterSensitiveLog: (obj: OpsItemNotFoundException) => any;
+}
+
+export interface OpsItemRelatedItemAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "OpsItemRelatedItemAlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+    ResourceUri?: string;
+    OpsItemId?: string;
+}
+export declare namespace OpsItemRelatedItemAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: OpsItemRelatedItemAlreadyExistsException) => any;
+}
+
+export interface CancelCommandRequest {
+    
+    CommandId: string | undefined;
+    
+    InstanceIds?: string[];
+}
+export declare namespace CancelCommandRequest {
+    
+    const filterSensitiveLog: (obj: CancelCommandRequest) => any;
+}
+
+export interface CancelCommandResult {
+}
+export declare namespace CancelCommandResult {
+    
+    const filterSensitiveLog: (obj: CancelCommandResult) => any;
+}
+
+export interface DuplicateInstanceId extends __SmithyException, $MetadataBearer {
+    name: "DuplicateInstanceId";
+    $fault: "client";
+}
+export declare namespace DuplicateInstanceId {
+    
+    const filterSensitiveLog: (obj: DuplicateInstanceId) => any;
+}
+
+export interface InvalidCommandId extends __SmithyException, $MetadataBearer {
+    name: "InvalidCommandId";
+    $fault: "client";
+}
+export declare namespace InvalidCommandId {
+    
+    const filterSensitiveLog: (obj: InvalidCommandId) => any;
+}
+
+export interface InvalidInstanceId extends __SmithyException, $MetadataBearer {
+    name: "InvalidInstanceId";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidInstanceId {
+    
+    const filterSensitiveLog: (obj: InvalidInstanceId) => any;
+}
+export interface CancelMaintenanceWindowExecutionRequest {
+    
+    WindowExecutionId: string | undefined;
+}
+export declare namespace CancelMaintenanceWindowExecutionRequest {
+    
+    const filterSensitiveLog: (obj: CancelMaintenanceWindowExecutionRequest) => any;
+}
+export interface CancelMaintenanceWindowExecutionResult {
+    
+    WindowExecutionId?: string;
+}
+export declare namespace CancelMaintenanceWindowExecutionResult {
+    
+    const filterSensitiveLog: (obj: CancelMaintenanceWindowExecutionResult) => any;
+}
+
+export interface DoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "DoesNotExistException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DoesNotExistException {
+    
+    const filterSensitiveLog: (obj: DoesNotExistException) => any;
+}
+export interface CreateActivationRequest {
+    
+    Description?: string;
+    
+    DefaultInstanceName?: string;
+    
+    IamRole: string | undefined;
+    
+    RegistrationLimit?: number;
+    
+    ExpirationDate?: Date;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateActivationRequest {
+    
+    const filterSensitiveLog: (obj: CreateActivationRequest) => any;
+}
+export interface CreateActivationResult {
+    
+    ActivationId?: string;
+    
+    ActivationCode?: string;
+}
+export declare namespace CreateActivationResult {
+    
+    const filterSensitiveLog: (obj: CreateActivationResult) => any;
+}
+
+export interface AssociationAlreadyExists extends __SmithyException, $MetadataBearer {
+    name: "AssociationAlreadyExists";
+    $fault: "client";
+}
+export declare namespace AssociationAlreadyExists {
+    
+    const filterSensitiveLog: (obj: AssociationAlreadyExists) => any;
+}
+
+export interface AssociationLimitExceeded extends __SmithyException, $MetadataBearer {
+    name: "AssociationLimitExceeded";
+    $fault: "client";
+}
+export declare namespace AssociationLimitExceeded {
+    
+    const filterSensitiveLog: (obj: AssociationLimitExceeded) => any;
+}
+export declare enum AssociationComplianceSeverity {
+    Critical = "CRITICAL",
+    High = "HIGH",
+    Low = "LOW",
+    Medium = "MEDIUM",
+    Unspecified = "UNSPECIFIED"
+}
+
+export interface S3OutputLocation {
+    
+    OutputS3Region?: string;
+    
+    OutputS3BucketName?: string;
+    
+    OutputS3KeyPrefix?: string;
+}
+export declare namespace S3OutputLocation {
+    
+    const filterSensitiveLog: (obj: S3OutputLocation) => any;
+}
+
+export interface InstanceAssociationOutputLocation {
+    
+    S3Location?: S3OutputLocation;
+}
+export declare namespace InstanceAssociationOutputLocation {
+    
+    const filterSensitiveLog: (obj: InstanceAssociationOutputLocation) => any;
+}
+export declare enum AssociationSyncCompliance {
+    Auto = "AUTO",
+    Manual = "MANUAL"
+}
+
+export interface TargetLocation {
+    
+    Accounts?: string[];
+    
+    Regions?: string[];
+    
+    TargetLocationMaxConcurrency?: string;
+    
+    TargetLocationMaxErrors?: string;
+    
+    ExecutionRoleName?: string;
+}
+export declare namespace TargetLocation {
+    
+    const filterSensitiveLog: (obj: TargetLocation) => any;
+}
+
+export interface Target {
+    
+    Key?: string;
+    
+    Values?: string[];
+}
+export declare namespace Target {
+    
+    const filterSensitiveLog: (obj: Target) => any;
+}
+export interface CreateAssociationRequest {
+    
+    Name: string | undefined;
+    
+    DocumentVersion?: string;
+    
+    InstanceId?: string;
+    
+    Parameters?: {
+        [key: string]: string[];
+    };
+    
+    Targets?: Target[];
+    
+    ScheduleExpression?: string;
+    
+    OutputLocation?: InstanceAssociationOutputLocation;
+    
+    AssociationName?: string;
+    
+    AutomationTargetParameterName?: string;
+    
+    MaxErrors?: string;
+    
+    MaxConcurrency?: string;
+    
+    ComplianceSeverity?: AssociationComplianceSeverity | string;
+    
+    SyncCompliance?: AssociationSyncCompliance | string;
+    
+    ApplyOnlyAtCronInterval?: boolean;
+    
+    CalendarNames?: string[];
+    
+    TargetLocations?: TargetLocation[];
+}
+export declare namespace CreateAssociationRequest {
+    
+    const filterSensitiveLog: (obj: CreateAssociationRequest) => any;
+}
+
+export interface AssociationOverview {
+    
+    Status?: string;
+    
+    DetailedStatus?: string;
+    
+    AssociationStatusAggregatedCount?: {
+        [key: string]: number;
+    };
+}
+export declare namespace AssociationOverview {
+    
+    const filterSensitiveLog: (obj: AssociationOverview) => any;
+}
+export declare enum AssociationStatusName {
+    Failed = "Failed",
+    Pending = "Pending",
+    Success = "Success"
+}
+
+export interface AssociationStatus {
+    
+    Date: Date | undefined;
+    
+    Name: AssociationStatusName | string | undefined;
+    
+    Message: string | undefined;
+    
+    AdditionalInfo?: string;
+}
+export declare namespace AssociationStatus {
+    
+    const filterSensitiveLog: (obj: AssociationStatus) => any;
+}
+
+export interface AssociationDescription {
+    
+    Name?: string;
+    
+    InstanceId?: string;
+    
+    AssociationVersion?: string;
+    
+    Date?: Date;
+    
+    LastUpdateAssociationDate?: Date;
+    
+    Status?: AssociationStatus;
+    
+    Overview?: AssociationOverview;
+    
+    DocumentVersion?: string;
+    
+    AutomationTargetParameterName?: string;
+    
+    Parameters?: {
+        [key: string]: string[];
+    };
+    
+    AssociationId?: string;
+    
+    Targets?: Target[];
+    
+    ScheduleExpression?: string;
+    
+    OutputLocation?: InstanceAssociationOutputLocation;
+    
+    LastExecutionDate?: Date;
+    
+    LastSuccessfulExecutionDate?: Date;
+    
+    AssociationName?: string;
+    
+    MaxErrors?: string;
+    
+    MaxConcurrency?: string;
+    
+    ComplianceSeverity?: AssociationComplianceSeverity | string;
+    
+    SyncCompliance?: AssociationSyncCompliance | string;
+    
+    ApplyOnlyAtCronInterval?: boolean;
+    
+    CalendarNames?: string[];
+    
+    TargetLocations?: TargetLocation[];
+}
+export declare namespace AssociationDescription {
+    
+    const filterSensitiveLog: (obj: AssociationDescription) => any;
+}
+export interface CreateAssociationResult {
+    
+    AssociationDescription?: AssociationDescription;
+}
+export declare namespace CreateAssociationResult {
+    
+    const filterSensitiveLog: (obj: CreateAssociationResult) => any;
+}
+
+export interface InvalidDocument extends __SmithyException, $MetadataBearer {
+    name: "InvalidDocument";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidDocument {
+    
+    const filterSensitiveLog: (obj: InvalidDocument) => any;
+}
+
+export interface InvalidDocumentVersion extends __SmithyException, $MetadataBearer {
+    name: "InvalidDocumentVersion";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidDocumentVersion {
+    
+    const filterSensitiveLog: (obj: InvalidDocumentVersion) => any;
+}
+
+export interface InvalidOutputLocation extends __SmithyException, $MetadataBearer {
+    name: "InvalidOutputLocation";
+    $fault: "client";
+}
+export declare namespace InvalidOutputLocation {
+    
+    const filterSensitiveLog: (obj: InvalidOutputLocation) => any;
+}
+
+export interface InvalidParameters extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameters";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidParameters {
+    
+    const filterSensitiveLog: (obj: InvalidParameters) => any;
+}
+
+export interface InvalidSchedule extends __SmithyException, $MetadataBearer {
+    name: "InvalidSchedule";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidSchedule {
+    
+    const filterSensitiveLog: (obj: InvalidSchedule) => any;
+}
+
+export interface InvalidTarget extends __SmithyException, $MetadataBearer {
+    name: "InvalidTarget";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidTarget {
+    
+    const filterSensitiveLog: (obj: InvalidTarget) => any;
+}
+
+export interface UnsupportedPlatformType extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedPlatformType";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace UnsupportedPlatformType {
+    
+    const filterSensitiveLog: (obj: UnsupportedPlatformType) => any;
+}
+
+export interface CreateAssociationBatchRequestEntry {
+    
+    Name: string | undefined;
+    
+    InstanceId?: string;
+    
+    Parameters?: {
+        [key: string]: string[];
+    };
+    
+    AutomationTargetParameterName?: string;
+    
+    DocumentVersion?: string;
+    
+    Targets?: Target[];
+    
+    ScheduleExpression?: string;
+    
+    OutputLocation?: InstanceAssociationOutputLocation;
+    
+    AssociationName?: string;
+    
+    MaxErrors?: string;
+    
+    MaxConcurrency?: string;
+    
+    ComplianceSeverity?: AssociationComplianceSeverity | string;
+    
+    SyncCompliance?: AssociationSyncCompliance | string;
+    
+    ApplyOnlyAtCronInterval?: boolean;
+    
+    CalendarNames?: string[];
+    
+    TargetLocations?: TargetLocation[];
+}
+export declare namespace CreateAssociationBatchRequestEntry {
+    
+    const filterSensitiveLog: (obj: CreateAssociationBatchRequestEntry) => any;
+}
+export interface CreateAssociationBatchRequest {
+    
+    Entries: CreateAssociationBatchRequestEntry[] | undefined;
+}
+export declare namespace CreateAssociationBatchRequest {
+    
+    const filterSensitiveLog: (obj: CreateAssociationBatchRequest) => any;
+}
+export declare type Fault = "Client" | "Server" | "Unknown";
+
+export interface FailedCreateAssociation {
+    
+    Entry?: CreateAssociationBatchRequestEntry;
+    
+    Message?: string;
+    
+    Fault?: Fault | string;
+}
+export declare namespace FailedCreateAssociation {
+    
+    const filterSensitiveLog: (obj: FailedCreateAssociation) => any;
+}
+export interface CreateAssociationBatchResult {
+    
+    Successful?: AssociationDescription[];
+    
+    Failed?: FailedCreateAssociation[];
+}
+export declare namespace CreateAssociationBatchResult {
+    
+    const filterSensitiveLog: (obj: CreateAssociationBatchResult) => any;
+}
+export declare enum AttachmentsSourceKey {
+    AttachmentReference = "AttachmentReference",
+    S3FileUrl = "S3FileUrl",
+    SourceUrl = "SourceUrl"
+}
+
+export interface AttachmentsSource {
+    
+    Key?: AttachmentsSourceKey | string;
+    
+    Values?: string[];
+    
+    Name?: string;
+}
+export declare namespace AttachmentsSource {
+    
+    const filterSensitiveLog: (obj: AttachmentsSource) => any;
+}
+export declare enum DocumentFormat {
+    JSON = "JSON",
+    TEXT = "TEXT",
+    YAML = "YAML"
+}
+export declare enum DocumentType {
+    ApplicationConfiguration = "ApplicationConfiguration",
+    ApplicationConfigurationSchema = "ApplicationConfigurationSchema",
+    Automation = "Automation",
+    ChangeCalendar = "ChangeCalendar",
+    ChangeTemplate = "Automation.ChangeTemplate",
+    Command = "Command",
+    DeploymentStrategy = "DeploymentStrategy",
+    Package = "Package",
+    Policy = "Policy",
+    ProblemAnalysis = "ProblemAnalysis",
+    ProblemAnalysisTemplate = "ProblemAnalysisTemplate",
+    Session = "Session"
+}
+
+export interface DocumentRequires {
+    
+    Name: string | undefined;
+    
+    Version?: string;
+}
+export declare namespace DocumentRequires {
+    
+    const filterSensitiveLog: (obj: DocumentRequires) => any;
+}
+export interface CreateDocumentRequest {
+    
+    Content: string | undefined;
+    
+    Requires?: DocumentRequires[];
+    
+    Attachments?: AttachmentsSource[];
+    
+    Name: string | undefined;
+    
+    DisplayName?: string;
+    
+    VersionName?: string;
+    
+    DocumentType?: DocumentType | string;
+    
+    DocumentFormat?: DocumentFormat | string;
+    
+    TargetType?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDocumentRequest {
+    
+    const filterSensitiveLog: (obj: CreateDocumentRequest) => any;
+}
+
+export interface AttachmentInformation {
+    
+    Name?: string;
+}
+export declare namespace AttachmentInformation {
+    
+    const filterSensitiveLog: (obj: AttachmentInformation) => any;
+}
+export declare enum DocumentHashType {
+    SHA1 = "Sha1",
+    SHA256 = "Sha256"
+}
+export declare type DocumentParameterType = "String" | "StringList";
+
+export interface DocumentParameter {
+    
+    Name?: string;
+    
+    Type?: DocumentParameterType | string;
+    
+    Description?: string;
+    
+    DefaultValue?: string;
+}
+export declare namespace DocumentParameter {
+    
+    const filterSensitiveLog: (obj: DocumentParameter) => any;
+}
+export declare enum PlatformType {
+    LINUX = "Linux",
+    WINDOWS = "Windows"
+}
+export declare enum ReviewStatus {
+    APPROVED = "APPROVED",
+    NOT_REVIEWED = "NOT_REVIEWED",
+    PENDING = "PENDING",
+    REJECTED = "REJECTED"
+}
+
+export interface ReviewInformation {
+    
+    ReviewedTime?: Date;
+    
+    Status?: ReviewStatus | string;
+    
+    Reviewer?: string;
+}
+export declare namespace ReviewInformation {
+    
+    const filterSensitiveLog: (obj: ReviewInformation) => any;
+}
+export declare enum DocumentStatus {
+    Active = "Active",
+    Creating = "Creating",
+    Deleting = "Deleting",
+    Failed = "Failed",
+    Updating = "Updating"
+}
+
+export interface DocumentDescription {
+    
+    Sha1?: string;
+    
+    Hash?: string;
+    
+    HashType?: DocumentHashType | string;
+    
+    Name?: string;
+    
+    DisplayName?: string;
+    
+    VersionName?: string;
+    
+    Owner?: string;
+    
+    CreatedDate?: Date;
+    
+    Status?: DocumentStatus | string;
+    
+    StatusInformation?: string;
+    
+    DocumentVersion?: string;
+    
+    Description?: string;
+    
+    Parameters?: DocumentParameter[];
+    
+    PlatformTypes?: (PlatformType | string)[];
+    
+    DocumentType?: DocumentType | string;
+    
+    SchemaVersion?: string;
+    
+    LatestVersion?: string;
+    
+    DefaultVersion?: string;
+    
+    DocumentFormat?: DocumentFormat | string;
+    
+    TargetType?: string;
+    
+    Tags?: Tag[];
+    
+    AttachmentsInformation?: AttachmentInformation[];
+    
+    Requires?: DocumentRequires[];
+    
+    Author?: string;
+    
+    ReviewInformation?: ReviewInformation[];
+    
+    ApprovedVersion?: string;
+    
+    PendingReviewVersion?: string;
+    
+    ReviewStatus?: ReviewStatus | string;
+}
+export declare namespace DocumentDescription {
+    
+    const filterSensitiveLog: (obj: DocumentDescription) => any;
+}
+export interface CreateDocumentResult {
+    
+    DocumentDescription?: DocumentDescription;
+}
+export declare namespace CreateDocumentResult {
+    
+    const filterSensitiveLog: (obj: CreateDocumentResult) => any;
+}
+
+export interface DocumentAlreadyExists extends __SmithyException, $MetadataBearer {
+    name: "DocumentAlreadyExists";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DocumentAlreadyExists {
+    
+    const filterSensitiveLog: (obj: DocumentAlreadyExists) => any;
+}
+
+export interface DocumentLimitExceeded extends __SmithyException, $MetadataBearer {
+    name: "DocumentLimitExceeded";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DocumentLimitExceeded {
+    
+    const filterSensitiveLog: (obj: DocumentLimitExceeded) => any;
+}
+
+export interface InvalidDocumentContent extends __SmithyException, $MetadataBearer {
+    name: "InvalidDocumentContent";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidDocumentContent {
+    
+    const filterSensitiveLog: (obj: InvalidDocumentContent) => any;
+}
+
+export interface InvalidDocumentSchemaVersion extends __SmithyException, $MetadataBearer {
+    name: "InvalidDocumentSchemaVersion";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidDocumentSchemaVersion {
+    
+    const filterSensitiveLog: (obj: InvalidDocumentSchemaVersion) => any;
+}
+
+export interface MaxDocumentSizeExceeded extends __SmithyException, $MetadataBearer {
+    name: "MaxDocumentSizeExceeded";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace MaxDocumentSizeExceeded {
+    
+    const filterSensitiveLog: (obj: MaxDocumentSizeExceeded) => any;
+}
+export interface CreateMaintenanceWindowRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    StartDate?: string;
+    
+    EndDate?: string;
+    
+    Schedule: string | undefined;
+    
+    ScheduleTimezone?: string;
+    
+    ScheduleOffset?: number;
+    
+    Duration: number | undefined;
+    
+    Cutoff: number | undefined;
+    
+    AllowUnassociatedTargets: boolean | undefined;
+    
+    ClientToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateMaintenanceWindowRequest {
+    
+    const filterSensitiveLog: (obj: CreateMaintenanceWindowRequest) => any;
+}
+export interface CreateMaintenanceWindowResult {
+    
+    WindowId?: string;
+}
+export declare namespace CreateMaintenanceWindowResult {
+    
+    const filterSensitiveLog: (obj: CreateMaintenanceWindowResult) => any;
+}
+
+export interface IdempotentParameterMismatch extends __SmithyException, $MetadataBearer {
+    name: "IdempotentParameterMismatch";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace IdempotentParameterMismatch {
+    
+    const filterSensitiveLog: (obj: IdempotentParameterMismatch) => any;
+}
+
+export interface ResourceLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceLimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceLimitExceededException {
+    
+    const filterSensitiveLog: (obj: ResourceLimitExceededException) => any;
+}
+
+export interface OpsItemNotification {
+    
+    Arn?: string;
+}
+export declare namespace OpsItemNotification {
+    
+    const filterSensitiveLog: (obj: OpsItemNotification) => any;
+}
+export declare enum OpsItemDataType {
+    SEARCHABLE_STRING = "SearchableString",
+    STRING = "String"
+}
+
+export interface OpsItemDataValue {
+    
+    Value?: string;
+    
+    Type?: OpsItemDataType | string;
+}
+export declare namespace OpsItemDataValue {
+    
+    const filterSensitiveLog: (obj: OpsItemDataValue) => any;
+}
+
+export interface RelatedOpsItem {
+    
+    OpsItemId: string | undefined;
+}
+export declare namespace RelatedOpsItem {
+    
+    const filterSensitiveLog: (obj: RelatedOpsItem) => any;
+}
+export interface CreateOpsItemRequest {
+    
+    Description: string | undefined;
+    
+    OpsItemType?: string;
+    
+    OperationalData?: {
+        [key: string]: OpsItemDataValue;
+    };
+    
+    Notifications?: OpsItemNotification[];
+    
+    Priority?: number;
+    
+    RelatedOpsItems?: RelatedOpsItem[];
+    
+    Source: string | undefined;
+    
+    Title: string | undefined;
+    
+    Tags?: Tag[];
+    
+    Category?: string;
+    
+    Severity?: string;
+    
+    ActualStartTime?: Date;
+    
+    ActualEndTime?: Date;
+    
+    PlannedStartTime?: Date;
+    
+    PlannedEndTime?: Date;
+}
+export declare namespace CreateOpsItemRequest {
+    
+    const filterSensitiveLog: (obj: CreateOpsItemRequest) => any;
+}
+export interface CreateOpsItemResponse {
+    
+    OpsItemId?: string;
+}
+export declare namespace CreateOpsItemResponse {
+    
+    const filterSensitiveLog: (obj: CreateOpsItemResponse) => any;
+}
+
+export interface OpsItemAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "OpsItemAlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+    OpsItemId?: string;
+}
+export declare namespace OpsItemAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: OpsItemAlreadyExistsException) => any;
+}
+
+export interface MetadataValue {
+    
+    Value?: string;
+}
+export declare namespace MetadataValue {
+    
+    const filterSensitiveLog: (obj: MetadataValue) => any;
+}
+export interface CreateOpsMetadataRequest {
+    
+    ResourceId: string | undefined;
+    
+    Metadata?: {
+        [key: string]: MetadataValue;
+    };
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateOpsMetadataRequest {
+    
+    const filterSensitiveLog: (obj: CreateOpsMetadataRequest) => any;
+}
+export interface CreateOpsMetadataResult {
+    
+    OpsMetadataArn?: string;
+}
+export declare namespace CreateOpsMetadataResult {
+    
+    const filterSensitiveLog: (obj: CreateOpsMetadataResult) => any;
+}
+
+export interface OpsMetadataAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "OpsMetadataAlreadyExistsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OpsMetadataAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: OpsMetadataAlreadyExistsException) => any;
+}
+
+export interface OpsMetadataInvalidArgumentException extends __SmithyException, $MetadataBearer {
+    name: "OpsMetadataInvalidArgumentException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OpsMetadataInvalidArgumentException {
+    
+    const filterSensitiveLog: (obj: OpsMetadataInvalidArgumentException) => any;
+}
+
+export interface OpsMetadataLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "OpsMetadataLimitExceededException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OpsMetadataLimitExceededException {
+    
+    const filterSensitiveLog: (obj: OpsMetadataLimitExceededException) => any;
+}
+
+export interface OpsMetadataTooManyUpdatesException extends __SmithyException, $MetadataBearer {
+    name: "OpsMetadataTooManyUpdatesException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OpsMetadataTooManyUpdatesException {
+    
+    const filterSensitiveLog: (obj: OpsMetadataTooManyUpdatesException) => any;
+}
+export declare enum PatchComplianceLevel {
+    Critical = "CRITICAL",
+    High = "HIGH",
+    Informational = "INFORMATIONAL",
+    Low = "LOW",
+    Medium = "MEDIUM",
+    Unspecified = "UNSPECIFIED"
+}
+export declare enum PatchFilterKey {
+    AdvisoryId = "ADVISORY_ID",
+    Arch = "ARCH",
+    BugzillaId = "BUGZILLA_ID",
+    CVEId = "CVE_ID",
+    Classification = "CLASSIFICATION",
+    Epoch = "EPOCH",
+    MsrcSeverity = "MSRC_SEVERITY",
+    Name = "NAME",
+    PatchId = "PATCH_ID",
+    PatchSet = "PATCH_SET",
+    Priority = "PRIORITY",
+    Product = "PRODUCT",
+    ProductFamily = "PRODUCT_FAMILY",
+    Release = "RELEASE",
+    Repository = "REPOSITORY",
+    Section = "SECTION",
+    Security = "SECURITY",
+    Severity = "SEVERITY",
+    Version = "VERSION"
+}
+
+export interface PatchFilter {
+    
+    Key: PatchFilterKey | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace PatchFilter {
+    
+    const filterSensitiveLog: (obj: PatchFilter) => any;
+}
+
+export interface PatchFilterGroup {
+    
+    PatchFilters: PatchFilter[] | undefined;
+}
+export declare namespace PatchFilterGroup {
+    
+    const filterSensitiveLog: (obj: PatchFilterGroup) => any;
+}
+
+export interface PatchRule {
+    
+    PatchFilterGroup: PatchFilterGroup | undefined;
+    
+    ComplianceLevel?: PatchComplianceLevel | string;
+    
+    ApproveAfterDays?: number;
+    
+    ApproveUntilDate?: string;
+    
+    EnableNonSecurity?: boolean;
+}
+export declare namespace PatchRule {
+    
+    const filterSensitiveLog: (obj: PatchRule) => any;
+}
+
+export interface PatchRuleGroup {
+    
+    PatchRules: PatchRule[] | undefined;
+}
+export declare namespace PatchRuleGroup {
+    
+    const filterSensitiveLog: (obj: PatchRuleGroup) => any;
+}
+export declare enum OperatingSystem {
+    AmazonLinux = "AMAZON_LINUX",
+    AmazonLinux2 = "AMAZON_LINUX_2",
+    CentOS = "CENTOS",
+    Debian = "DEBIAN",
+    MacOS = "MACOS",
+    OracleLinux = "ORACLE_LINUX",
+    RedhatEnterpriseLinux = "REDHAT_ENTERPRISE_LINUX",
+    Suse = "SUSE",
+    Ubuntu = "UBUNTU",
+    Windows = "WINDOWS"
+}
+export declare enum PatchAction {
+    AllowAsDependency = "ALLOW_AS_DEPENDENCY",
+    Block = "BLOCK"
+}
+
+export interface PatchSource {
+    
+    Name: string | undefined;
+    
+    Products: string[] | undefined;
+    
+    Configuration: string | undefined;
+}
+export declare namespace PatchSource {
+    
+    const filterSensitiveLog: (obj: PatchSource) => any;
+}
+export interface CreatePatchBaselineRequest {
+    
+    OperatingSystem?: OperatingSystem | string;
+    
+    Name: string | undefined;
+    
+    GlobalFilters?: PatchFilterGroup;
+    
+    ApprovalRules?: PatchRuleGroup;
+    
+    ApprovedPatches?: string[];
+    
+    ApprovedPatchesComplianceLevel?: PatchComplianceLevel | string;
+    
+    ApprovedPatchesEnableNonSecurity?: boolean;
+    
+    RejectedPatches?: string[];
+    
+    RejectedPatchesAction?: PatchAction | string;
+    
+    Description?: string;
+    
+    Sources?: PatchSource[];
+    
+    ClientToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreatePatchBaselineRequest {
+    
+    const filterSensitiveLog: (obj: CreatePatchBaselineRequest) => any;
+}
+export interface CreatePatchBaselineResult {
+    
+    BaselineId?: string;
+}
+export declare namespace CreatePatchBaselineResult {
+    
+    const filterSensitiveLog: (obj: CreatePatchBaselineResult) => any;
+}
+
+export interface ResourceDataSyncDestinationDataSharing {
+    
+    DestinationDataSharingType?: string;
+}
+export declare namespace ResourceDataSyncDestinationDataSharing {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncDestinationDataSharing) => any;
+}
+export declare enum ResourceDataSyncS3Format {
+    JSON_SERDE = "JsonSerDe"
+}
+
+export interface ResourceDataSyncS3Destination {
+    
+    BucketName: string | undefined;
+    
+    Prefix?: string;
+    
+    SyncFormat: ResourceDataSyncS3Format | string | undefined;
+    
+    Region: string | undefined;
+    
+    AWSKMSKeyARN?: string;
+    
+    DestinationDataSharing?: ResourceDataSyncDestinationDataSharing;
+}
+export declare namespace ResourceDataSyncS3Destination {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncS3Destination) => any;
+}
+
+export interface ResourceDataSyncOrganizationalUnit {
+    
+    OrganizationalUnitId?: string;
+}
+export declare namespace ResourceDataSyncOrganizationalUnit {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncOrganizationalUnit) => any;
+}
+
+export interface ResourceDataSyncAwsOrganizationsSource {
+    
+    OrganizationSourceType: string | undefined;
+    
+    OrganizationalUnits?: ResourceDataSyncOrganizationalUnit[];
+}
+export declare namespace ResourceDataSyncAwsOrganizationsSource {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncAwsOrganizationsSource) => any;
+}
+
+export interface ResourceDataSyncSource {
+    
+    SourceType: string | undefined;
+    
+    AwsOrganizationsSource?: ResourceDataSyncAwsOrganizationsSource;
+    
+    SourceRegions: string[] | undefined;
+    
+    IncludeFutureRegions?: boolean;
+    
+    EnableAllOpsDataSources?: boolean;
+}
+export declare namespace ResourceDataSyncSource {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncSource) => any;
+}
+export interface CreateResourceDataSyncRequest {
+    
+    SyncName: string | undefined;
+    
+    S3Destination?: ResourceDataSyncS3Destination;
+    
+    SyncType?: string;
+    
+    SyncSource?: ResourceDataSyncSource;
+}
+export declare namespace CreateResourceDataSyncRequest {
+    
+    const filterSensitiveLog: (obj: CreateResourceDataSyncRequest) => any;
+}
+export interface CreateResourceDataSyncResult {
+}
+export declare namespace CreateResourceDataSyncResult {
+    
+    const filterSensitiveLog: (obj: CreateResourceDataSyncResult) => any;
+}
+
+export interface ResourceDataSyncAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceDataSyncAlreadyExistsException";
+    $fault: "client";
+    SyncName?: string;
+}
+export declare namespace ResourceDataSyncAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncAlreadyExistsException) => any;
+}
+
+export interface ResourceDataSyncCountExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceDataSyncCountExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceDataSyncCountExceededException {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncCountExceededException) => any;
+}
+
+export interface ResourceDataSyncInvalidConfigurationException extends __SmithyException, $MetadataBearer {
+    name: "ResourceDataSyncInvalidConfigurationException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceDataSyncInvalidConfigurationException {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncInvalidConfigurationException) => any;
+}
+export interface DeleteActivationRequest {
+    
+    ActivationId: string | undefined;
+}
+export declare namespace DeleteActivationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteActivationRequest) => any;
+}
+export interface DeleteActivationResult {
+}
+export declare namespace DeleteActivationResult {
+    
+    const filterSensitiveLog: (obj: DeleteActivationResult) => any;
+}
+
+export interface InvalidActivation extends __SmithyException, $MetadataBearer {
+    name: "InvalidActivation";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidActivation {
+    
+    const filterSensitiveLog: (obj: InvalidActivation) => any;
+}
+
+export interface InvalidActivationId extends __SmithyException, $MetadataBearer {
+    name: "InvalidActivationId";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidActivationId {
+    
+    const filterSensitiveLog: (obj: InvalidActivationId) => any;
+}
+
+export interface AssociationDoesNotExist extends __SmithyException, $MetadataBearer {
+    name: "AssociationDoesNotExist";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AssociationDoesNotExist {
+    
+    const filterSensitiveLog: (obj: AssociationDoesNotExist) => any;
+}
+export interface DeleteAssociationRequest {
+    
+    Name?: string;
+    
+    InstanceId?: string;
+    
+    AssociationId?: string;
+}
+export declare namespace DeleteAssociationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAssociationRequest) => any;
+}
+export interface DeleteAssociationResult {
+}
+export declare namespace DeleteAssociationResult {
+    
+    const filterSensitiveLog: (obj: DeleteAssociationResult) => any;
+}
+
+export interface AssociatedInstances extends __SmithyException, $MetadataBearer {
+    name: "AssociatedInstances";
+    $fault: "client";
+}
+export declare namespace AssociatedInstances {
+    
+    const filterSensitiveLog: (obj: AssociatedInstances) => any;
+}
+export interface DeleteDocumentRequest {
+    
+    Name: string | undefined;
+    
+    DocumentVersion?: string;
+    
+    VersionName?: string;
+    
+    Force?: boolean;
+}
+export declare namespace DeleteDocumentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentRequest) => any;
+}
+export interface DeleteDocumentResult {
+}
+export declare namespace DeleteDocumentResult {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentResult) => any;
+}
+
+export interface InvalidDocumentOperation extends __SmithyException, $MetadataBearer {
+    name: "InvalidDocumentOperation";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidDocumentOperation {
+    
+    const filterSensitiveLog: (obj: InvalidDocumentOperation) => any;
+}
+export declare enum InventorySchemaDeleteOption {
+    DELETE_SCHEMA = "DeleteSchema",
+    DISABLE_SCHEMA = "DisableSchema"
+}
+export interface DeleteInventoryRequest {
+    
+    TypeName: string | undefined;
+    
+    SchemaDeleteOption?: InventorySchemaDeleteOption | string;
+    
+    DryRun?: boolean;
+    
+    ClientToken?: string;
+}
+export declare namespace DeleteInventoryRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInventoryRequest) => any;
+}
+
+export interface InventoryDeletionSummaryItem {
+    
+    Version?: string;
+    
+    Count?: number;
+    
+    RemainingCount?: number;
+}
+export declare namespace InventoryDeletionSummaryItem {
+    
+    const filterSensitiveLog: (obj: InventoryDeletionSummaryItem) => any;
+}
+
+export interface InventoryDeletionSummary {
+    
+    TotalCount?: number;
+    
+    RemainingCount?: number;
+    
+    SummaryItems?: InventoryDeletionSummaryItem[];
+}
+export declare namespace InventoryDeletionSummary {
+    
+    const filterSensitiveLog: (obj: InventoryDeletionSummary) => any;
+}
+export interface DeleteInventoryResult {
+    
+    DeletionId?: string;
+    
+    TypeName?: string;
+    
+    DeletionSummary?: InventoryDeletionSummary;
+}
+export declare namespace DeleteInventoryResult {
+    
+    const filterSensitiveLog: (obj: DeleteInventoryResult) => any;
+}
+
+export interface InvalidDeleteInventoryParametersException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeleteInventoryParametersException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidDeleteInventoryParametersException {
+    
+    const filterSensitiveLog: (obj: InvalidDeleteInventoryParametersException) => any;
+}
+
+export interface InvalidInventoryRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidInventoryRequestException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidInventoryRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidInventoryRequestException) => any;
+}
+
+export interface InvalidOptionException extends __SmithyException, $MetadataBearer {
+    name: "InvalidOptionException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidOptionException {
+    
+    const filterSensitiveLog: (obj: InvalidOptionException) => any;
+}
+
+export interface InvalidTypeNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTypeNameException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidTypeNameException {
+    
+    const filterSensitiveLog: (obj: InvalidTypeNameException) => any;
+}
+export interface DeleteMaintenanceWindowRequest {
+    
+    WindowId: string | undefined;
+}
+export declare namespace DeleteMaintenanceWindowRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMaintenanceWindowRequest) => any;
+}
+export interface DeleteMaintenanceWindowResult {
+    
+    WindowId?: string;
+}
+export declare namespace DeleteMaintenanceWindowResult {
+    
+    const filterSensitiveLog: (obj: DeleteMaintenanceWindowResult) => any;
+}
+export interface DeleteOpsMetadataRequest {
+    
+    OpsMetadataArn: string | undefined;
+}
+export declare namespace DeleteOpsMetadataRequest {
+    
+    const filterSensitiveLog: (obj: DeleteOpsMetadataRequest) => any;
+}
+export interface DeleteOpsMetadataResult {
+}
+export declare namespace DeleteOpsMetadataResult {
+    
+    const filterSensitiveLog: (obj: DeleteOpsMetadataResult) => any;
+}
+
+export interface OpsMetadataNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "OpsMetadataNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OpsMetadataNotFoundException {
+    
+    const filterSensitiveLog: (obj: OpsMetadataNotFoundException) => any;
+}
+export interface DeleteParameterRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteParameterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteParameterRequest) => any;
+}
+export interface DeleteParameterResult {
+}
+export declare namespace DeleteParameterResult {
+    
+    const filterSensitiveLog: (obj: DeleteParameterResult) => any;
+}
+
+export interface ParameterNotFound extends __SmithyException, $MetadataBearer {
+    name: "ParameterNotFound";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ParameterNotFound {
+    
+    const filterSensitiveLog: (obj: ParameterNotFound) => any;
+}
+export interface DeleteParametersRequest {
+    
+    Names: string[] | undefined;
+}
+export declare namespace DeleteParametersRequest {
+    
+    const filterSensitiveLog: (obj: DeleteParametersRequest) => any;
+}
+export interface DeleteParametersResult {
+    
+    DeletedParameters?: string[];
+    
+    InvalidParameters?: string[];
+}
+export declare namespace DeleteParametersResult {
+    
+    const filterSensitiveLog: (obj: DeleteParametersResult) => any;
+}
+export interface DeletePatchBaselineRequest {
+    
+    BaselineId: string | undefined;
+}
+export declare namespace DeletePatchBaselineRequest {
+    
+    const filterSensitiveLog: (obj: DeletePatchBaselineRequest) => any;
+}
+export interface DeletePatchBaselineResult {
+    
+    BaselineId?: string;
+}
+export declare namespace DeletePatchBaselineResult {
+    
+    const filterSensitiveLog: (obj: DeletePatchBaselineResult) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+export interface DeleteResourceDataSyncRequest {
+    
+    SyncName: string | undefined;
+    
+    SyncType?: string;
+}
+export declare namespace DeleteResourceDataSyncRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourceDataSyncRequest) => any;
+}
+export interface DeleteResourceDataSyncResult {
+}
+export declare namespace DeleteResourceDataSyncResult {
+    
+    const filterSensitiveLog: (obj: DeleteResourceDataSyncResult) => any;
+}
+
+export interface ResourceDataSyncNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceDataSyncNotFoundException";
+    $fault: "client";
+    SyncName?: string;
+    SyncType?: string;
+    Message?: string;
+}
+export declare namespace ResourceDataSyncNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceDataSyncNotFoundException) => any;
+}
+export interface DeregisterManagedInstanceRequest {
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DeregisterManagedInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterManagedInstanceRequest) => any;
+}
+export interface DeregisterManagedInstanceResult {
+}
+export declare namespace DeregisterManagedInstanceResult {
+    
+    const filterSensitiveLog: (obj: DeregisterManagedInstanceResult) => any;
+}
+export interface DeregisterPatchBaselineForPatchGroupRequest {
+    
+    BaselineId: string | undefined;
+    
+    PatchGroup: string | undefined;
+}
+export declare namespace DeregisterPatchBaselineForPatchGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterPatchBaselineForPatchGroupRequest) => any;
+}
+export interface DeregisterPatchBaselineForPatchGroupResult {
+    
+    BaselineId?: string;
+    
+    PatchGroup?: string;
+}
+export declare namespace DeregisterPatchBaselineForPatchGroupResult {
+    
+    const filterSensitiveLog: (obj: DeregisterPatchBaselineForPatchGroupResult) => any;
+}
+export interface DeregisterTargetFromMaintenanceWindowRequest {
+    
+    WindowId: string | undefined;
+    
+    WindowTargetId: string | undefined;
+    
+    Safe?: boolean;
+}
+export declare namespace DeregisterTargetFromMaintenanceWindowRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterTargetFromMaintenanceWindowRequest) => any;
+}
+export interface DeregisterTargetFromMaintenanceWindowResult {
+    
+    WindowId?: string;
+    
+    WindowTargetId?: string;
+}
+export declare namespace DeregisterTargetFromMaintenanceWindowResult {
+    
+    const filterSensitiveLog: (obj: DeregisterTargetFromMaintenanceWindowResult) => any;
+}
+
+export interface TargetInUseException extends __SmithyException, $MetadataBearer {
+    name: "TargetInUseException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TargetInUseException {
+    
+    const filterSensitiveLog: (obj: TargetInUseException) => any;
+}
+export interface DeregisterTaskFromMaintenanceWindowRequest {
+    
+    WindowId: string | undefined;
+    
+    WindowTaskId: string | undefined;
+}
+export declare namespace DeregisterTaskFromMaintenanceWindowRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterTaskFromMaintenanceWindowRequest) => any;
+}
+export interface DeregisterTaskFromMaintenanceWindowResult {
+    
+    WindowId?: string;
+    
+    WindowTaskId?: string;
+}
+export declare namespace DeregisterTaskFromMaintenanceWindowResult {
+    
+    const filterSensitiveLog: (obj: DeregisterTaskFromMaintenanceWindowResult) => any;
+}
+export declare enum DescribeActivationsFilterKeys {
+    ACTIVATION_IDS = "ActivationIds",
+    DEFAULT_INSTANCE_NAME = "DefaultInstanceName",
+    IAM_ROLE = "IamRole"
+}
+
+export interface DescribeActivationsFilter {
+    
+    FilterKey?: DescribeActivationsFilterKeys | string;
+    
+    FilterValues?: string[];
+}
+export declare namespace DescribeActivationsFilter {
+    
+    const filterSensitiveLog: (obj: DescribeActivationsFilter) => any;
+}
+export interface DescribeActivationsRequest {
+    
+    Filters?: DescribeActivationsFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeActivationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeActivationsRequest) => any;
+}
+export interface DescribeActivationsResult {
+    
+    ActivationList?: Activation[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeActivationsResult {
+    
+    const filterSensitiveLog: (obj: DescribeActivationsResult) => any;
+}
+
+export interface InvalidFilter extends __SmithyException, $MetadataBearer {
+    name: "InvalidFilter";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidFilter {
+    
+    const filterSensitiveLog: (obj: InvalidFilter) => any;
+}
+
+export interface InvalidNextToken extends __SmithyException, $MetadataBearer {
+    name: "InvalidNextToken";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidNextToken {
+    
+    const filterSensitiveLog: (obj: InvalidNextToken) => any;
+}
+export interface DescribeAssociationRequest {
+    
+    Name?: string;
+    
+    InstanceId?: string;
+    
+    AssociationId?: string;
+    
+    AssociationVersion?: string;
+}
+export declare namespace DescribeAssociationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAssociationRequest) => any;
+}
+export interface DescribeAssociationResult {
+    
+    AssociationDescription?: AssociationDescription;
+}
+export declare namespace DescribeAssociationResult {
+    
+    const filterSensitiveLog: (obj: DescribeAssociationResult) => any;
+}
+
+export interface InvalidAssociationVersion extends __SmithyException, $MetadataBearer {
+    name: "InvalidAssociationVersion";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidAssociationVersion {
+    
+    const filterSensitiveLog: (obj: InvalidAssociationVersion) => any;
+}
+export declare enum AssociationExecutionFilterKey {
+    CreatedTime = "CreatedTime",
+    ExecutionId = "ExecutionId",
+    Status = "Status"
+}
+export declare enum AssociationFilterOperatorType {
+    Equal = "EQUAL",
+    GreaterThan = "GREATER_THAN",
+    LessThan = "LESS_THAN"
+}
+
+export interface AssociationExecutionFilter {
+    
+    Key: AssociationExecutionFilterKey | string | undefined;
+    
+    Value: string | undefined;
+    
+    Type: AssociationFilterOperatorType | string | undefined;
+}
+export declare namespace AssociationExecutionFilter {
+    
+    const filterSensitiveLog: (obj: AssociationExecutionFilter) => any;
+}
+export interface DescribeAssociationExecutionsRequest {
+    
+    AssociationId: string | undefined;
+    
+    Filters?: AssociationExecutionFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAssociationExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAssociationExecutionsRequest) => any;
+}
+
+export interface AssociationExecution {
+    
+    AssociationId?: string;
+    
+    AssociationVersion?: string;
+    
+    ExecutionId?: string;
+    
+    Status?: string;
+    
+    DetailedStatus?: string;
+    
+    CreatedTime?: Date;
+    
+    LastExecutionDate?: Date;
+    
+    ResourceCountByStatus?: string;
+}
+export declare namespace AssociationExecution {
+    
+    const filterSensitiveLog: (obj: AssociationExecution) => any;
+}
+export interface DescribeAssociationExecutionsResult {
+    
+    AssociationExecutions?: AssociationExecution[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAssociationExecutionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeAssociationExecutionsResult) => any;
+}
+
+export interface AssociationExecutionDoesNotExist extends __SmithyException, $MetadataBearer {
+    name: "AssociationExecutionDoesNotExist";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AssociationExecutionDoesNotExist {
+    
+    const filterSensitiveLog: (obj: AssociationExecutionDoesNotExist) => any;
+}
+export declare enum AssociationExecutionTargetsFilterKey {
+    ResourceId = "ResourceId",
+    ResourceType = "ResourceType",
+    Status = "Status"
+}
+
+export interface AssociationExecutionTargetsFilter {
+    
+    Key: AssociationExecutionTargetsFilterKey | string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace AssociationExecutionTargetsFilter {
+    
+    const filterSensitiveLog: (obj: AssociationExecutionTargetsFilter) => any;
+}
+export interface DescribeAssociationExecutionTargetsRequest {
+    
+    AssociationId: string | undefined;
+    
+    ExecutionId: string | undefined;
+    
+    Filters?: AssociationExecutionTargetsFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAssociationExecutionTargetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAssociationExecutionTargetsRequest) => any;
+}
+
+export interface OutputSource {
+    
+    OutputSourceId?: string;
+    
+    OutputSourceType?: string;
+}
+export declare namespace OutputSource {
+    
+    const filterSensitiveLog: (obj: OutputSource) => any;
+}
+
+export interface AssociationExecutionTarget {
+    
+    AssociationId?: string;
+    
+    AssociationVersion?: string;
+    
+    ExecutionId?: string;
+    
+    ResourceId?: string;
+    
+    ResourceType?: string;
+    
+    Status?: string;
+    
+    DetailedStatus?: string;
+    
+    LastExecutionDate?: Date;
+    
+    OutputSource?: OutputSource;
+}
+export declare namespace AssociationExecutionTarget {
+    
+    const filterSensitiveLog: (obj: AssociationExecutionTarget) => any;
+}
+export interface DescribeAssociationExecutionTargetsResult {
+    
+    AssociationExecutionTargets?: AssociationExecutionTarget[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAssociationExecutionTargetsResult {
+    
+    const filterSensitiveLog: (obj: DescribeAssociationExecutionTargetsResult) => any;
+}
+export declare enum AutomationExecutionFilterKey {
+    AUTOMATION_SUBTYPE = "AutomationSubtype",
+    AUTOMATION_TYPE = "AutomationType",
+    CURRENT_ACTION = "CurrentAction",
+    DOCUMENT_NAME_PREFIX = "DocumentNamePrefix",
+    EXECUTION_ID = "ExecutionId",
+    EXECUTION_STATUS = "ExecutionStatus",
+    OPS_ITEM_ID = "OpsItemId",
+    PARENT_EXECUTION_ID = "ParentExecutionId",
+    START_TIME_AFTER = "StartTimeAfter",
+    START_TIME_BEFORE = "StartTimeBefore",
+    TAG_KEY = "TagKey",
+    TARGET_RESOURCE_GROUP = "TargetResourceGroup"
+}
+
+export interface AutomationExecutionFilter {
+    
+    Key: AutomationExecutionFilterKey | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace AutomationExecutionFilter {
+    
+    const filterSensitiveLog: (obj: AutomationExecutionFilter) => any;
+}
+export interface DescribeAutomationExecutionsRequest {
+    
+    Filters?: AutomationExecutionFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAutomationExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAutomationExecutionsRequest) => any;
+}
+export declare enum AutomationExecutionStatus {
+    APPROVED = "Approved",
+    CANCELLED = "Cancelled",
+    CANCELLING = "Cancelling",
+    CHANGE_CALENDAR_OVERRIDE_APPROVED = "ChangeCalendarOverrideApproved",
+    CHANGE_CALENDAR_OVERRIDE_REJECTED = "ChangeCalendarOverrideRejected",
+    COMPLETED_WITH_FAILURE = "CompletedWithFailure",
+    COMPLETED_WITH_SUCCESS = "CompletedWithSuccess",
+    FAILED = "Failed",
+    INPROGRESS = "InProgress",
+    PENDING = "Pending",
+    PENDING_APPROVAL = "PendingApproval",
+    PENDING_CHANGE_CALENDAR_OVERRIDE = "PendingChangeCalendarOverride",
+    REJECTED = "Rejected",
+    RUNBOOK_INPROGRESS = "RunbookInProgress",
+    SCHEDULED = "Scheduled",
+    SUCCESS = "Success",
+    TIMEDOUT = "TimedOut",
+    WAITING = "Waiting"
+}
+export declare enum AutomationSubtype {
+    ChangeRequest = "ChangeRequest"
+}
+export declare enum AutomationType {
+    CrossAccount = "CrossAccount",
+    Local = "Local"
+}
+export declare enum ExecutionMode {
+    Auto = "Auto",
+    Interactive = "Interactive"
+}
+
+export interface ResolvedTargets {
+    
+    ParameterValues?: string[];
+    
+    Truncated?: boolean;
+}
+export declare namespace ResolvedTargets {
+    
+    const filterSensitiveLog: (obj: ResolvedTargets) => any;
+}
+
+export interface Runbook {
+    
+    DocumentName: string | undefined;
+    
+    DocumentVersion?: string;
+    
+    Parameters?: {
+        [key: string]: string[];
+    };
+    
+    TargetParameterName?: string;
+    
+    Targets?: Target[];
+    
+    MaxConcurrency?: string;
+    
+    MaxErrors?: string;
+    
+    TargetLocations?: TargetLocation[];
+}
+export declare namespace Runbook {
+    
+    const filterSensitiveLog: (obj: Runbook) => any;
+}
+
+export interface AutomationExecutionMetadata {
+    
+    AutomationExecutionId?: string;
+    
+    DocumentName?: string;
+    
+    DocumentVersion?: string;
+    
+    AutomationExecutionStatus?: AutomationExecutionStatus | string;
+    
+    ExecutionStartTime?: Date;
+    
+    ExecutionEndTime?: Date;
+    
+    ExecutedBy?: string;
+    
+    LogFile?: string;
+    
+    Outputs?: {
+        [key: string]: string[];
+    };
+    
+    Mode?: ExecutionMode | string;
+    
+    ParentAutomationExecutionId?: string;
+    
+    CurrentStepName?: string;
+    
+    CurrentAction?: string;
+    
+    FailureMessage?: string;
+    
+    TargetParameterName?: string;
+    
+    Targets?: Target[];
+    
+    TargetMaps?: {
+        [key: string]: string[];
+    }[];
+    
+    ResolvedTargets?: ResolvedTargets;
+    
+    MaxConcurrency?: string;
+    
+    MaxErrors?: string;
+    
+    Target?: string;
+    
+    AutomationType?: AutomationType | string;
+    
+    AutomationSubtype?: AutomationSubtype | string;
+    
+    ScheduledTime?: Date;
+    
+    Runbooks?: Runbook[];
+    
+    OpsItemId?: string;
+    
+    AssociationId?: string;
+    
+    ChangeRequestName?: string;
+}
+export declare namespace AutomationExecutionMetadata {
+    
+    const filterSensitiveLog: (obj: AutomationExecutionMetadata) => any;
+}
+export interface DescribeAutomationExecutionsResult {
+    
+    AutomationExecutionMetadataList?: AutomationExecutionMetadata[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAutomationExecutionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeAutomationExecutionsResult) => any;
+}
+
+export interface InvalidFilterKey extends __SmithyException, $MetadataBearer {
+    name: "InvalidFilterKey";
+    $fault: "client";
+}
+export declare namespace InvalidFilterKey {
+    
+    const filterSensitiveLog: (obj: InvalidFilterKey) => any;
+}
+
+export interface InvalidFilterValue extends __SmithyException, $MetadataBearer {
+    name: "InvalidFilterValue";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidFilterValue {
+    
+    const filterSensitiveLog: (obj: InvalidFilterValue) => any;
+}
+
+export interface AutomationExecutionNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "AutomationExecutionNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AutomationExecutionNotFoundException {
+    
+    const filterSensitiveLog: (obj: AutomationExecutionNotFoundException) => any;
+}
+export declare enum StepExecutionFilterKey {
+    ACTION = "Action",
+    START_TIME_AFTER = "StartTimeAfter",
+    START_TIME_BEFORE = "StartTimeBefore",
+    STEP_EXECUTION_ID = "StepExecutionId",
+    STEP_EXECUTION_STATUS = "StepExecutionStatus",
+    STEP_NAME = "StepName"
+}
+
+export interface StepExecutionFilter {
+    
+    Key: StepExecutionFilterKey | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace StepExecutionFilter {
+    
+    const filterSensitiveLog: (obj: StepExecutionFilter) => any;
+}
+export interface DescribeAutomationStepExecutionsRequest {
+    
+    AutomationExecutionId: string | undefined;
+    
+    Filters?: StepExecutionFilter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ReverseOrder?: boolean;
+}
+export declare namespace DescribeAutomationStepExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAutomationStepExecutionsRequest) => any;
+}
+
+export interface FailureDetails {
+    
+    FailureStage?: string;
+    
+    FailureType?: string;
+    
+    Details?: {
+        [key: string]: string[];
+    };
+}
+export declare namespace FailureDetails {
+    
+    const filterSensitiveLog: (obj: FailureDetails) => any;
+}
+
+export interface StepExecution {
+    
+    StepName?: string;
+    
+    Action?: string;
+    
+    TimeoutSeconds?: number;
+    
+    OnFailure?: string;
+    
+    MaxAttempts?: number;
+    
+    ExecutionStartTime?: Date;
+    
+    ExecutionEndTime?: Date;
+    
+    StepStatus?: AutomationExecutionStatus | string;
+    
+    ResponseCode?: string;
+    
+    Inputs?: {
+        [key: string]: string;
+    };
+    
+    Outputs?: {
+        [key: string]: string[];
+    };
+    
+    Response?: string;
+    
+    FailureMessage?: string;
+    
+    FailureDetails?: FailureDetails;
+    
+    StepExecutionId?: string;
+    
+    OverriddenParameters?: {
+        [key: string]: string[];
+    };
+    
+    IsEnd?: boolean;
+    
+    NextStep?: string;
+    
+    IsCritical?: boolean;
+    
+    ValidNextSteps?: string[];
+    
+    Targets?: Target[];
+    
+    TargetLocation?: TargetLocation;
+}
+export declare namespace StepExecution {
+    
+    const filterSensitiveLog: (obj: StepExecution) => any;
+}
+export interface DescribeAutomationStepExecutionsResult {
+    
+    StepExecutions?: StepExecution[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAutomationStepExecutionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeAutomationStepExecutionsResult) => any;
+}
+
+export interface PatchOrchestratorFilter {
+    
+    Key?: string;
+    
+    Values?: string[];
+}
+export declare namespace PatchOrchestratorFilter {
+    
+    const filterSensitiveLog: (obj: PatchOrchestratorFilter) => any;
+}
+export interface DescribeAvailablePatchesRequest {
+    
+    Filters?: PatchOrchestratorFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAvailablePatchesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAvailablePatchesRequest) => any;
+}
+
+export interface Patch {
+    
+    Id?: string;
+    
+    ReleaseDate?: Date;
+    
+    Title?: string;
+    
+    Description?: string;
+    
+    ContentUrl?: string;
+    
+    Vendor?: string;
+    
+    ProductFamily?: string;
+    
+    Product?: string;
+    
+    Classification?: string;
+    
+    MsrcSeverity?: string;
+    
+    KbNumber?: string;
+    
+    MsrcNumber?: string;
+    
+    Language?: string;
+    
+    AdvisoryIds?: string[];
+    
+    BugzillaIds?: string[];
+    
+    CVEIds?: string[];
+    
+    Name?: string;
+    
+    Epoch?: number;
+    
+    Version?: string;
+    
+    Release?: string;
+    
+    Arch?: string;
+    
+    Severity?: string;
+    
+    Repository?: string;
+}
+export declare namespace Patch {
+    
+    const filterSensitiveLog: (obj: Patch) => any;
+}
+export interface DescribeAvailablePatchesResult {
+    
+    Patches?: Patch[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAvailablePatchesResult {
+    
+    const filterSensitiveLog: (obj: DescribeAvailablePatchesResult) => any;
+}
+export interface DescribeDocumentRequest {
+    
+    Name: string | undefined;
+    
+    DocumentVersion?: string;
+    
+    VersionName?: string;
+}
+export declare namespace DescribeDocumentRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentRequest) => any;
+}
+export interface DescribeDocumentResult {
+    
+    Document?: DocumentDescription;
+}
+export declare namespace DescribeDocumentResult {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentResult) => any;
+}
+export declare enum DocumentPermissionType {
+    SHARE = "Share"
+}
+export interface DescribeDocumentPermissionRequest {
+    
+    Name: string | undefined;
+    
+    PermissionType: DocumentPermissionType | string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeDocumentPermissionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentPermissionRequest) => any;
+}
+export interface DescribeDocumentPermissionResponse {
+    
+    AccountIds?: string[];
+    
+    AccountSharingInfoList?: AccountSharingInfo[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeDocumentPermissionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentPermissionResponse) => any;
+}
+
+export interface InvalidPermissionType extends __SmithyException, $MetadataBearer {
+    name: "InvalidPermissionType";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidPermissionType {
+    
+    const filterSensitiveLog: (obj: InvalidPermissionType) => any;
+}
+export interface DescribeEffectiveInstanceAssociationsRequest {
+    
+    InstanceId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEffectiveInstanceAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEffectiveInstanceAssociationsRequest) => any;
+}
+
+export interface InstanceAssociation {
+    
+    AssociationId?: string;
+    
+    InstanceId?: string;
+    
+    Content?: string;
+    
+    AssociationVersion?: string;
+}
+export declare namespace InstanceAssociation {
+    
+    const filterSensitiveLog: (obj: InstanceAssociation) => any;
+}
+export interface DescribeEffectiveInstanceAssociationsResult {
+    
+    Associations?: InstanceAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEffectiveInstanceAssociationsResult {
+    
+    const filterSensitiveLog: (obj: DescribeEffectiveInstanceAssociationsResult) => any;
+}
+export interface DescribeEffectivePatchesForPatchBaselineRequest {
+    
+    BaselineId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEffectivePatchesForPatchBaselineRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEffectivePatchesForPatchBaselineRequest) => any;
+}
+export declare enum PatchDeploymentStatus {
+    Approved = "APPROVED",
+    ExplicitApproved = "EXPLICIT_APPROVED",
+    ExplicitRejected = "EXPLICIT_REJECTED",
+    PendingApproval = "PENDING_APPROVAL"
+}
+
+export interface PatchStatus {
+    
+    DeploymentStatus?: PatchDeploymentStatus | string;
+    
+    ComplianceLevel?: PatchComplianceLevel | string;
+    
+    ApprovalDate?: Date;
+}
+export declare namespace PatchStatus {
+    
+    const filterSensitiveLog: (obj: PatchStatus) => any;
+}
+
+export interface EffectivePatch {
+    
+    Patch?: Patch;
+    
+    PatchStatus?: PatchStatus;
+}
+export declare namespace EffectivePatch {
+    
+    const filterSensitiveLog: (obj: EffectivePatch) => any;
+}
+export interface DescribeEffectivePatchesForPatchBaselineResult {
+    
+    EffectivePatches?: EffectivePatch[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEffectivePatchesForPatchBaselineResult {
+    
+    const filterSensitiveLog: (obj: DescribeEffectivePatchesForPatchBaselineResult) => any;
+}
+
+export interface UnsupportedOperatingSystem extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedOperatingSystem";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace UnsupportedOperatingSystem {
+    
+    const filterSensitiveLog: (obj: UnsupportedOperatingSystem) => any;
+}
+export interface DescribeInstanceAssociationsStatusRequest {
+    
+    InstanceId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstanceAssociationsStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceAssociationsStatusRequest) => any;
+}
+
+export interface S3OutputUrl {
+    
+    OutputUrl?: string;
+}
+export declare namespace S3OutputUrl {
+    
+    const filterSensitiveLog: (obj: S3OutputUrl) => any;
+}
+
+export interface InstanceAssociationOutputUrl {
+    
+    S3OutputUrl?: S3OutputUrl;
+}
+export declare namespace InstanceAssociationOutputUrl {
+    
+    const filterSensitiveLog: (obj: InstanceAssociationOutputUrl) => any;
+}
+
+export interface InstanceAssociationStatusInfo {
+    
+    AssociationId?: string;
+    
+    Name?: string;
+    
+    DocumentVersion?: string;
+    
+    AssociationVersion?: string;
+    
+    InstanceId?: string;
+    
+    ExecutionDate?: Date;
+    
+    Status?: string;
+    
+    DetailedStatus?: string;
+    
+    ExecutionSummary?: string;
+    
+    ErrorCode?: string;
+    
+    OutputUrl?: InstanceAssociationOutputUrl;
+    
+    AssociationName?: string;
+}
+export declare namespace InstanceAssociationStatusInfo {
+    
+    const filterSensitiveLog: (obj: InstanceAssociationStatusInfo) => any;
+}
+export interface DescribeInstanceAssociationsStatusResult {
+    
+    InstanceAssociationStatusInfos?: InstanceAssociationStatusInfo[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstanceAssociationsStatusResult {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceAssociationsStatusResult) => any;
+}
+
+export interface InstanceInformationStringFilter {
+    
+    Key: string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace InstanceInformationStringFilter {
+    
+    const filterSensitiveLog: (obj: InstanceInformationStringFilter) => any;
+}
+export declare enum InstanceInformationFilterKey {
+    ACTIVATION_IDS = "ActivationIds",
+    AGENT_VERSION = "AgentVersion",
+    ASSOCIATION_STATUS = "AssociationStatus",
+    IAM_ROLE = "IamRole",
+    INSTANCE_IDS = "InstanceIds",
+    PING_STATUS = "PingStatus",
+    PLATFORM_TYPES = "PlatformTypes",
+    RESOURCE_TYPE = "ResourceType"
+}
+
+export interface InstanceInformationFilter {
+    
+    key: InstanceInformationFilterKey | string | undefined;
+    
+    valueSet: string[] | undefined;
+}
+export declare namespace InstanceInformationFilter {
+    
+    const filterSensitiveLog: (obj: InstanceInformationFilter) => any;
+}
+export interface DescribeInstanceInformationRequest {
+    
+    InstanceInformationFilterList?: InstanceInformationFilter[];
+    
+    Filters?: InstanceInformationStringFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstanceInformationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceInformationRequest) => any;
+}
+
+export interface InstanceAggregatedAssociationOverview {
+    
+    DetailedStatus?: string;
+    
+    InstanceAssociationStatusAggregatedCount?: {
+        [key: string]: number;
+    };
+}
+export declare namespace InstanceAggregatedAssociationOverview {
+    
+    const filterSensitiveLog: (obj: InstanceAggregatedAssociationOverview) => any;
+}
+export declare enum PingStatus {
+    CONNECTION_LOST = "ConnectionLost",
+    INACTIVE = "Inactive",
+    ONLINE = "Online"
+}
+export declare enum ResourceType {
+    DOCUMENT = "Document",
+    EC2_INSTANCE = "EC2Instance",
+    MANAGED_INSTANCE = "ManagedInstance"
+}
+
+export interface InstanceInformation {
+    
+    InstanceId?: string;
+    
+    PingStatus?: PingStatus | string;
+    
+    LastPingDateTime?: Date;
+    
+    AgentVersion?: string;
+    
+    IsLatestVersion?: boolean;
+    
+    PlatformType?: PlatformType | string;
+    
+    PlatformName?: string;
+    
+    PlatformVersion?: string;
+    
+    ActivationId?: string;
+    
+    IamRole?: string;
+    
+    RegistrationDate?: Date;
+    
+    ResourceType?: ResourceType | string;
+    
+    Name?: string;
+    
+    IPAddress?: string;
+    
+    ComputerName?: string;
+    
+    AssociationStatus?: string;
+    
+    LastAssociationExecutionDate?: Date;
+    
+    LastSuccessfulAssociationExecutionDate?: Date;
+    
+    AssociationOverview?: InstanceAggregatedAssociationOverview;
+}
+export declare namespace InstanceInformation {
+    
+    const filterSensitiveLog: (obj: InstanceInformation) => any;
+}
+export interface DescribeInstanceInformationResult {
+    
+    InstanceInformationList?: InstanceInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstanceInformationResult {
+    
+    const filterSensitiveLog: (obj: DescribeInstanceInformationResult) => any;
+}
+
+export interface InvalidInstanceInformationFilterValue extends __SmithyException, $MetadataBearer {
+    name: "InvalidInstanceInformationFilterValue";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidInstanceInformationFilterValue {
+    
+    const filterSensitiveLog: (obj: InvalidInstanceInformationFilterValue) => any;
+}
+export interface DescribeInstancePatchesRequest {
+    
+    InstanceId: string | undefined;
+    
+    Filters?: PatchOrchestratorFilter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeInstancePatchesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstancePatchesRequest) => any;
+}
+export declare enum PatchComplianceDataState {
+    Failed = "FAILED",
+    Installed = "INSTALLED",
+    InstalledOther = "INSTALLED_OTHER",
+    InstalledPendingReboot = "INSTALLED_PENDING_REBOOT",
+    InstalledRejected = "INSTALLED_REJECTED",
+    Missing = "MISSING",
+    NotApplicable = "NOT_APPLICABLE"
+}
+
+export interface PatchComplianceData {
+    
+    Title: string | undefined;
+    
+    KBId: string | undefined;
+    
+    Classification: string | undefined;
+    
+    Severity: string | undefined;
+    
+    State: PatchComplianceDataState | string | undefined;
+    
+    InstalledTime: Date | undefined;
+    
+    CVEIds?: string;
+}
+export declare namespace PatchComplianceData {
+    
+    const filterSensitiveLog: (obj: PatchComplianceData) => any;
+}
+export interface DescribeInstancePatchesResult {
+    
+    Patches?: PatchComplianceData[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstancePatchesResult {
+    
+    const filterSensitiveLog: (obj: DescribeInstancePatchesResult) => any;
+}
+export interface DescribeInstancePatchStatesRequest {
+    
+    InstanceIds: string[] | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeInstancePatchStatesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstancePatchStatesRequest) => any;
+}
+export declare enum PatchOperationType {
+    INSTALL = "Install",
+    SCAN = "Scan"
+}
+export declare enum RebootOption {
+    NO_REBOOT = "NoReboot",
+    REBOOT_IF_NEEDED = "RebootIfNeeded"
+}
+
+export interface InstancePatchState {
+    
+    InstanceId: string | undefined;
+    
+    PatchGroup: string | undefined;
+    
+    BaselineId: string | undefined;
+    
+    SnapshotId?: string;
+    
+    InstallOverrideList?: string;
+    
+    OwnerInformation?: string;
+    
+    InstalledCount?: number;
+    
+    InstalledOtherCount?: number;
+    
+    InstalledPendingRebootCount?: number;
+    
+    InstalledRejectedCount?: number;
+    
+    MissingCount?: number;
+    
+    FailedCount?: number;
+    
+    UnreportedNotApplicableCount?: number;
+    
+    NotApplicableCount?: number;
+    
+    OperationStartTime: Date | undefined;
+    
+    OperationEndTime: Date | undefined;
+    
+    Operation: PatchOperationType | string | undefined;
+    
+    LastNoRebootInstallOperationTime?: Date;
+    
+    RebootOption?: RebootOption | string;
+    
+    CriticalNonCompliantCount?: number;
+    
+    SecurityNonCompliantCount?: number;
+    
+    OtherNonCompliantCount?: number;
+}
+export declare namespace InstancePatchState {
+    
+    const filterSensitiveLog: (obj: InstancePatchState) => any;
+}
+export interface DescribeInstancePatchStatesResult {
+    
+    InstancePatchStates?: InstancePatchState[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstancePatchStatesResult {
+    
+    const filterSensitiveLog: (obj: DescribeInstancePatchStatesResult) => any;
+}
+export declare enum InstancePatchStateOperatorType {
+    EQUAL = "Equal",
+    GREATER_THAN = "GreaterThan",
+    LESS_THAN = "LessThan",
+    NOT_EQUAL = "NotEqual"
+}
+
+export interface InstancePatchStateFilter {
+    
+    Key: string | undefined;
+    
+    Values: string[] | undefined;
+    
+    Type: InstancePatchStateOperatorType | string | undefined;
+}
+export declare namespace InstancePatchStateFilter {
+    
+    const filterSensitiveLog: (obj: InstancePatchStateFilter) => any;
+}
+export interface DescribeInstancePatchStatesForPatchGroupRequest {
+    
+    PatchGroup: string | undefined;
+    
+    Filters?: InstancePatchStateFilter[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeInstancePatchStatesForPatchGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstancePatchStatesForPatchGroupRequest) => any;
+}
+export interface DescribeInstancePatchStatesForPatchGroupResult {
+    
+    InstancePatchStates?: InstancePatchState[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstancePatchStatesForPatchGroupResult {
+    
+    const filterSensitiveLog: (obj: DescribeInstancePatchStatesForPatchGroupResult) => any;
+}
+export interface DescribeInventoryDeletionsRequest {
+    
+    DeletionId?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeInventoryDeletionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInventoryDeletionsRequest) => any;
+}
+export declare enum InventoryDeletionStatus {
+    COMPLETE = "Complete",
+    IN_PROGRESS = "InProgress"
+}
+
+export interface InventoryDeletionStatusItem {
+    
+    DeletionId?: string;
+    
+    TypeName?: string;
+    
+    DeletionStartTime?: Date;
+    
+    LastStatus?: InventoryDeletionStatus | string;
+    
+    LastStatusMessage?: string;
+    
+    DeletionSummary?: InventoryDeletionSummary;
+    
+    LastStatusUpdateTime?: Date;
+}
+export declare namespace InventoryDeletionStatusItem {
+    
+    const filterSensitiveLog: (obj: InventoryDeletionStatusItem) => any;
+}
+export interface DescribeInventoryDeletionsResult {
+    
+    InventoryDeletions?: InventoryDeletionStatusItem[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInventoryDeletionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeInventoryDeletionsResult) => any;
+}
+
+export interface InvalidDeletionIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeletionIdException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidDeletionIdException {
+    
+    const filterSensitiveLog: (obj: InvalidDeletionIdException) => any;
+}
+
+export interface MaintenanceWindowFilter {
+    
+    Key?: string;
+    
+    Values?: string[];
+}
+export declare namespace MaintenanceWindowFilter {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowFilter) => any;
+}
+export interface DescribeMaintenanceWindowExecutionsRequest {
+    
+    WindowId: string | undefined;
+    
+    Filters?: MaintenanceWindowFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowExecutionsRequest) => any;
+}
+export declare enum MaintenanceWindowExecutionStatus {
+    Cancelled = "CANCELLED",
+    Cancelling = "CANCELLING",
+    Failed = "FAILED",
+    InProgress = "IN_PROGRESS",
+    Pending = "PENDING",
+    SkippedOverlapping = "SKIPPED_OVERLAPPING",
+    Success = "SUCCESS",
+    TimedOut = "TIMED_OUT"
+}
+
+export interface MaintenanceWindowExecution {
+    
+    WindowId?: string;
+    
+    WindowExecutionId?: string;
+    
+    Status?: MaintenanceWindowExecutionStatus | string;
+    
+    StatusDetails?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+}
+export declare namespace MaintenanceWindowExecution {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowExecution) => any;
+}
+export interface DescribeMaintenanceWindowExecutionsResult {
+    
+    WindowExecutions?: MaintenanceWindowExecution[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowExecutionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowExecutionsResult) => any;
+}
+export interface DescribeMaintenanceWindowExecutionTaskInvocationsRequest {
+    
+    WindowExecutionId: string | undefined;
+    
+    TaskId: string | undefined;
+    
+    Filters?: MaintenanceWindowFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowExecutionTaskInvocationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowExecutionTaskInvocationsRequest) => any;
+}
+export declare enum MaintenanceWindowTaskType {
+    Automation = "AUTOMATION",
+    Lambda = "LAMBDA",
+    RunCommand = "RUN_COMMAND",
+    StepFunctions = "STEP_FUNCTIONS"
+}
+
+export interface MaintenanceWindowExecutionTaskInvocationIdentity {
+    
+    WindowExecutionId?: string;
+    
+    TaskExecutionId?: string;
+    
+    InvocationId?: string;
+    
+    ExecutionId?: string;
+    
+    TaskType?: MaintenanceWindowTaskType | string;
+    
+    Parameters?: string;
+    
+    Status?: MaintenanceWindowExecutionStatus | string;
+    
+    StatusDetails?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    OwnerInformation?: string;
+    
+    WindowTargetId?: string;
+}
+export declare namespace MaintenanceWindowExecutionTaskInvocationIdentity {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowExecutionTaskInvocationIdentity) => any;
+}
+export interface DescribeMaintenanceWindowExecutionTaskInvocationsResult {
+    
+    WindowExecutionTaskInvocationIdentities?: MaintenanceWindowExecutionTaskInvocationIdentity[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowExecutionTaskInvocationsResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowExecutionTaskInvocationsResult) => any;
+}
+export interface DescribeMaintenanceWindowExecutionTasksRequest {
+    
+    WindowExecutionId: string | undefined;
+    
+    Filters?: MaintenanceWindowFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowExecutionTasksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowExecutionTasksRequest) => any;
+}
+
+export interface MaintenanceWindowExecutionTaskIdentity {
+    
+    WindowExecutionId?: string;
+    
+    TaskExecutionId?: string;
+    
+    Status?: MaintenanceWindowExecutionStatus | string;
+    
+    StatusDetails?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    TaskArn?: string;
+    
+    TaskType?: MaintenanceWindowTaskType | string;
+}
+export declare namespace MaintenanceWindowExecutionTaskIdentity {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowExecutionTaskIdentity) => any;
+}
+export interface DescribeMaintenanceWindowExecutionTasksResult {
+    
+    WindowExecutionTaskIdentities?: MaintenanceWindowExecutionTaskIdentity[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowExecutionTasksResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowExecutionTasksResult) => any;
+}
+export interface DescribeMaintenanceWindowsRequest {
+    
+    Filters?: MaintenanceWindowFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowsRequest) => any;
+}
+
+export interface MaintenanceWindowIdentity {
+    
+    WindowId?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Enabled?: boolean;
+    
+    Duration?: number;
+    
+    Cutoff?: number;
+    
+    Schedule?: string;
+    
+    ScheduleTimezone?: string;
+    
+    ScheduleOffset?: number;
+    
+    EndDate?: string;
+    
+    StartDate?: string;
+    
+    NextExecutionTime?: string;
+}
+export declare namespace MaintenanceWindowIdentity {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowIdentity) => any;
+}
+export interface DescribeMaintenanceWindowsResult {
+    
+    WindowIdentities?: MaintenanceWindowIdentity[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowsResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowsResult) => any;
+}
+export declare enum MaintenanceWindowResourceType {
+    Instance = "INSTANCE",
+    ResourceGroup = "RESOURCE_GROUP"
+}
+export interface DescribeMaintenanceWindowScheduleRequest {
+    
+    WindowId?: string;
+    
+    Targets?: Target[];
+    
+    ResourceType?: MaintenanceWindowResourceType | string;
+    
+    Filters?: PatchOrchestratorFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowScheduleRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowScheduleRequest) => any;
+}
+
+export interface ScheduledWindowExecution {
+    
+    WindowId?: string;
+    
+    Name?: string;
+    
+    ExecutionTime?: string;
+}
+export declare namespace ScheduledWindowExecution {
+    
+    const filterSensitiveLog: (obj: ScheduledWindowExecution) => any;
+}
+export interface DescribeMaintenanceWindowScheduleResult {
+    
+    ScheduledWindowExecutions?: ScheduledWindowExecution[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowScheduleResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowScheduleResult) => any;
+}
+export interface DescribeMaintenanceWindowsForTargetRequest {
+    
+    Targets: Target[] | undefined;
+    
+    ResourceType: MaintenanceWindowResourceType | string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowsForTargetRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowsForTargetRequest) => any;
+}
+
+export interface MaintenanceWindowIdentityForTarget {
+    
+    WindowId?: string;
+    
+    Name?: string;
+}
+export declare namespace MaintenanceWindowIdentityForTarget {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowIdentityForTarget) => any;
+}
+export interface DescribeMaintenanceWindowsForTargetResult {
+    
+    WindowIdentities?: MaintenanceWindowIdentityForTarget[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowsForTargetResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowsForTargetResult) => any;
+}
+export interface DescribeMaintenanceWindowTargetsRequest {
+    
+    WindowId: string | undefined;
+    
+    Filters?: MaintenanceWindowFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowTargetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowTargetsRequest) => any;
+}
+
+export interface MaintenanceWindowTarget {
+    
+    WindowId?: string;
+    
+    WindowTargetId?: string;
+    
+    ResourceType?: MaintenanceWindowResourceType | string;
+    
+    Targets?: Target[];
+    
+    OwnerInformation?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace MaintenanceWindowTarget {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowTarget) => any;
+}
+export interface DescribeMaintenanceWindowTargetsResult {
+    
+    Targets?: MaintenanceWindowTarget[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowTargetsResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowTargetsResult) => any;
+}
+export interface DescribeMaintenanceWindowTasksRequest {
+    
+    WindowId: string | undefined;
+    
+    Filters?: MaintenanceWindowFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowTasksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowTasksRequest) => any;
+}
+export declare enum MaintenanceWindowTaskCutoffBehavior {
+    CancelTask = "CANCEL_TASK",
+    ContinueTask = "CONTINUE_TASK"
+}
+
+export interface LoggingInfo {
+    
+    S3BucketName: string | undefined;
+    
+    S3KeyPrefix?: string;
+    
+    S3Region: string | undefined;
+}
+export declare namespace LoggingInfo {
+    
+    const filterSensitiveLog: (obj: LoggingInfo) => any;
+}
+
+export interface MaintenanceWindowTaskParameterValueExpression {
+    
+    Values?: string[];
+}
+export declare namespace MaintenanceWindowTaskParameterValueExpression {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowTaskParameterValueExpression) => any;
+}
+
+export interface MaintenanceWindowTask {
+    
+    WindowId?: string;
+    
+    WindowTaskId?: string;
+    
+    TaskArn?: string;
+    
+    Type?: MaintenanceWindowTaskType | string;
+    
+    Targets?: Target[];
+    
+    TaskParameters?: {
+        [key: string]: MaintenanceWindowTaskParameterValueExpression;
+    };
+    
+    Priority?: number;
+    
+    LoggingInfo?: LoggingInfo;
+    
+    ServiceRoleArn?: string;
+    
+    MaxConcurrency?: string;
+    
+    MaxErrors?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    CutoffBehavior?: MaintenanceWindowTaskCutoffBehavior | string;
+}
+export declare namespace MaintenanceWindowTask {
+    
+    const filterSensitiveLog: (obj: MaintenanceWindowTask) => any;
+}
+export interface DescribeMaintenanceWindowTasksResult {
+    
+    Tasks?: MaintenanceWindowTask[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMaintenanceWindowTasksResult {
+    
+    const filterSensitiveLog: (obj: DescribeMaintenanceWindowTasksResult) => any;
+}
+export declare enum OpsItemFilterKey {
+    ACTUAL_END_TIME = "ActualEndTime",
+    ACTUAL_START_TIME = "ActualStartTime",
+    AUTOMATION_ID = "AutomationId",
+    CATEGORY = "Category",
+    CHANGE_REQUEST_APPROVER_ARN = "ChangeRequestByApproverArn",
+    CHANGE_REQUEST_APPROVER_NAME = "ChangeRequestByApproverName",
+    CHANGE_REQUEST_REQUESTER_ARN = "ChangeRequestByRequesterArn",
+    CHANGE_REQUEST_REQUESTER_NAME = "ChangeRequestByRequesterName",
+    CHANGE_REQUEST_TARGETS_RESOURCE_GROUP = "ChangeRequestByTargetsResourceGroup",
+    CHANGE_REQUEST_TEMPLATE = "ChangeRequestByTemplate",
+    CREATED_BY = "CreatedBy",
+    CREATED_TIME = "CreatedTime",
+    INSIGHT_TYPE = "InsightByType",
+    LAST_MODIFIED_TIME = "LastModifiedTime",
+    OPERATIONAL_DATA = "OperationalData",
+    OPERATIONAL_DATA_KEY = "OperationalDataKey",
+    OPERATIONAL_DATA_VALUE = "OperationalDataValue",
+    OPSITEM_ID = "OpsItemId",
+    OPSITEM_TYPE = "OpsItemType",
+    PLANNED_END_TIME = "PlannedEndTime",
+    PLANNED_START_TIME = "PlannedStartTime",
+    PRIORITY = "Priority",
+    RESOURCE_ID = "ResourceId",
+    SEVERITY = "Severity",
+    SOURCE = "Source",
+    STATUS = "Status",
+    TITLE = "Title"
+}
+export declare enum OpsItemFilterOperator {
+    CONTAINS = "Contains",
+    EQUAL = "Equal",
+    GREATER_THAN = "GreaterThan",
+    LESS_THAN = "LessThan"
+}
+
+export interface OpsItemFilter {
+    
+    Key: OpsItemFilterKey | string | undefined;
+    
+    Values: string[] | undefined;
+    
+    Operator: OpsItemFilterOperator | string | undefined;
+}
+export declare namespace OpsItemFilter {
+    
+    const filterSensitiveLog: (obj: OpsItemFilter) => any;
+}
+export interface DescribeOpsItemsRequest {
+    
+    OpsItemFilters?: OpsItemFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOpsItemsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOpsItemsRequest) => any;
+}
+export declare enum OpsItemStatus {
+    APPROVED = "Approved",
+    CANCELLED = "Cancelled",
+    CANCELLING = "Cancelling",
+    CHANGE_CALENDAR_OVERRIDE_APPROVED = "ChangeCalendarOverrideApproved",
+    CHANGE_CALENDAR_OVERRIDE_REJECTED = "ChangeCalendarOverrideRejected",
+    CLOSED = "Closed",
+    COMPLETED_WITH_FAILURE = "CompletedWithFailure",
+    COMPLETED_WITH_SUCCESS = "CompletedWithSuccess",
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    OPEN = "Open",
+    PENDING = "Pending",
+    PENDING_APPROVAL = "PendingApproval",
+    PENDING_CHANGE_CALENDAR_OVERRIDE = "PendingChangeCalendarOverride",
+    REJECTED = "Rejected",
+    RESOLVED = "Resolved",
+    RUNBOOK_IN_PROGRESS = "RunbookInProgress",
+    SCHEDULED = "Scheduled",
+    TIMED_OUT = "TimedOut"
+}
+
+export interface OpsItemSummary {
+    
+    CreatedBy?: string;
+    
+    CreatedTime?: Date;
+    
+    LastModifiedBy?: string;
+    
+    LastModifiedTime?: Date;
+    
+    Priority?: number;
+    
+    Source?: string;
+    
+    Status?: OpsItemStatus | string;
+    
+    OpsItemId?: string;
+    
+    Title?: string;
+    
+    OperationalData?: {
+        [key: string]: OpsItemDataValue;
+    };
+    
+    Category?: string;
+    
+    Severity?: string;
+    
+    OpsItemType?: string;
+    
+    ActualStartTime?: Date;
+    
+    ActualEndTime?: Date;
+    
+    PlannedStartTime?: Date;
+    
+    PlannedEndTime?: Date;
+}
+export declare namespace OpsItemSummary {
+    
+    const filterSensitiveLog: (obj: OpsItemSummary) => any;
+}
+export interface DescribeOpsItemsResponse {
+    
+    NextToken?: string;
+    
+    OpsItemSummaries?: OpsItemSummary[];
+}
+export declare namespace DescribeOpsItemsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOpsItemsResponse) => any;
+}
+export declare enum ParametersFilterKey {
+    KEY_ID = "KeyId",
+    NAME = "Name",
+    TYPE = "Type"
+}
+
+export interface ParametersFilter {
+    
+    Key: ParametersFilterKey | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace ParametersFilter {
+    
+    const filterSensitiveLog: (obj: ParametersFilter) => any;
+}
+
+export interface ParameterStringFilter {
+    
+    Key: string | undefined;
+    
+    Option?: string;
+    
+    Values?: string[];
+}
+export declare namespace ParameterStringFilter {
+    
+    const filterSensitiveLog: (obj: ParameterStringFilter) => any;
+}
+export interface DescribeParametersRequest {
+    
+    Filters?: ParametersFilter[];
+    
+    ParameterFilters?: ParameterStringFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeParametersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeParametersRequest) => any;
+}
+
+export interface ParameterInlinePolicy {
+    
+    PolicyText?: string;
+    
+    PolicyType?: string;
+    
+    PolicyStatus?: string;
+}
+export declare namespace ParameterInlinePolicy {
+    
+    const filterSensitiveLog: (obj: ParameterInlinePolicy) => any;
+}
+export declare enum ParameterTier {
+    ADVANCED = "Advanced",
+    INTELLIGENT_TIERING = "Intelligent-Tiering",
+    STANDARD = "Standard"
+}
+export declare enum ParameterType {
+    SECURE_STRING = "SecureString",
+    STRING = "String",
+    STRING_LIST = "StringList"
+}
+
+export interface ParameterMetadata {
+    
+    Name?: string;
+    
+    Type?: ParameterType | string;
+    
+    KeyId?: string;
+    
+    LastModifiedDate?: Date;
+    
+    LastModifiedUser?: string;
+    
+    Description?: string;
+    
+    AllowedPattern?: string;
+    
+    Version?: number;
+    
+    Tier?: ParameterTier | string;
+    
+    Policies?: ParameterInlinePolicy[];
+    
+    DataType?: string;
+}
+export declare namespace ParameterMetadata {
+    
+    const filterSensitiveLog: (obj: ParameterMetadata) => any;
+}