const ServiceAPIVersion = "2014-11-06"

const ServiceID = "SSM"

type AddTagsToResourceInput struct {

	// The resource ID you want to tag. Use the ID of the resource. Here are some
	// examples: ManagedInstance: mi-012345abcde MaintenanceWindow: mw-012345abcde
	// PatchBaseline: pb-012345abcde For the Document and Parameter values, use the
	// name of the resource. The ManagedInstance type for this API action is only for
	// on-premises managed instances. You must specify the name of the managed instance
	// in the following format: mi-ID_number. For example, mi-1a2b3c4d5e6f.
	//
	// This member is required.
	ResourceId *string

	// Specifies the type of resource you are tagging. The ManagedInstance type for
	// this API action is for on-premises managed instances. You must specify the name
	// of the managed instance in the following format: mi-ID_number. For example,
	// mi-1a2b3c4d5e6f.
	//
	// This member is required.
	ResourceType types.ResourceTypeForTagging

	// One or more tags. The value parameter is required, but if you don't want the tag
	// to have a value, specify the parameter with no value, and we set the value to an
	// empty string. Do not enter personally identifiable information in this field.
	//
	// This member is required.
	Tags []types.Tag
}

type AddTagsToResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CancelCommandInput struct {

	// The ID of the command you want to cancel.
	//
	// This member is required.
	CommandId *string

	// (Optional) A list of instance IDs on which you want to cancel the command. If
	// not provided, the command is canceled on every instance on which it was
	// requested.
	InstanceIds []string
}

type CancelCommandOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CancelMaintenanceWindowExecutionInput struct {

	// The ID of the maintenance window execution to stop.
	//
	// This member is required.
	WindowExecutionId *string
}

type CancelMaintenanceWindowExecutionOutput struct {

	// The ID of the maintenance window execution that has been stopped.
	WindowExecutionId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CommandExecutedWaiter struct {
	// contains filtered or unexported fields
}

type CommandExecutedWaiterOptions struct {

	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// CommandExecutedWaiter will use default minimum delay of 5 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or set
	// to zero, CommandExecutedWaiter will use default max delay of 120 seconds. Note
	// that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *GetCommandInvocationInput, *GetCommandInvocationOutput, error) (bool, error)
}

type CreateActivationInput struct {

	// The Amazon Identity and Access Management (IAM) role that you want to assign to
	// the managed instance. This IAM role must provide AssumeRole permissions for the
	// Systems Manager service principal ssm.amazonaws.com. For more information, see
	// Create an IAM service role for a hybrid environment
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-service-role.html)
	// in the AWS Systems Manager User Guide.
	//
	// This member is required.
	IamRole *string

	// The name of the registered, managed instance as it will appear in the Systems
	// Manager console or when you use the AWS command line tools to list Systems
	// Manager resources. Do not enter personally identifiable information in this
	// field.
	DefaultInstanceName *string

	// A user-defined description of the resource that you want to register with
	// Systems Manager. Do not enter personally identifiable information in this field.
	Description *string

	// The date by which this activation request should expire. The default value is 24
	// hours.
	ExpirationDate *time.Time

	// Specify the maximum number of managed instances you want to register. The
	// default value is 1 instance.
	RegistrationLimit int32

	// Optional metadata that you assign to a resource. Tags enable you to categorize a
	// resource in different ways, such as by purpose, owner, or environment. For
	// example, you might want to tag an activation to identify which servers or
	// virtual machines (VMs) in your on-premises environment you intend to activate.
	// In this case, you could specify the following key name/value pairs:
	//
	// *
	// Key=OS,Value=Windows
	//
	// * Key=Environment,Value=Production
	//
	// When you install SSM
	// Agent on your on-premises servers and VMs, you specify an activation ID and
	// code. When you specify the activation ID and code, tags assigned to the
	// activation are automatically applied to the on-premises servers or VMs. You
	// can't add tags to or delete tags from an existing activation. You can tag your
	// on-premises servers and VMs after they connect to Systems Manager for the first
	// time and are assigned a managed instance ID. This means they are listed in the
	// AWS Systems Manager console with an ID that is prefixed with "mi-". For
	// information about how to add tags to your managed instances, see
	// AddTagsToResource. For information about how to remove tags from your managed
	// instances, see RemoveTagsFromResource.
	Tags []types.Tag
}

type CreateActivationOutput struct {

	// The code the system generates when it processes the activation. The activation
	// code functions like a password to validate the activation ID.
	ActivationCode *string

	// The ID number generated by the system when it processed the activation. The
	// activation ID functions like a user name.
	ActivationId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateAssociationBatchInput struct {

	// One or more associations.
	//
	// This member is required.
	Entries []types.CreateAssociationBatchRequestEntry
}

type CreateAssociationBatchOutput struct {

	// Information about the associations that failed.
	Failed []types.FailedCreateAssociation

	// Information about the associations that succeeded.
	Successful []types.AssociationDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateAssociationInput struct {

	// The name of the SSM document that contains the configuration information for the
	// instance. You can specify Command or Automation documents. You can specify
	// AWS-predefined documents, documents you created, or a document that is shared
	// with you from another account. For SSM documents that are shared with you from
	// other AWS accounts, you must specify the complete SSM document ARN, in the
	// following format: arn:partition:ssm:region:account-id:document/document-name
	// For example: arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document For
	// AWS-predefined documents and SSM documents you created in your account, you only
	// need to specify the document name. For example, AWS-ApplyPatchBaseline or
	// My-Document.
	//
	// This member is required.
	Name *string

	// By default, when you create a new associations, the system runs it immediately
	// after it is created and then according to the schedule you specified. Specify
	// this option if you don't want an association to run immediately after you create
	// it. This parameter is not supported for rate expressions.
	ApplyOnlyAtCronInterval bool

	// Specify a descriptive name for the association.
	AssociationName *string

	// Specify the target for the association. This target is required for associations
	// that use an Automation document and target resources by using rate controls.
	AutomationTargetParameterName *string

	// The severity level to assign to the association.
	ComplianceSeverity types.AssociationComplianceSeverity

	// The document version you want to associate with the target(s). Can be a specific
	// version or the default version.
	DocumentVersion *string

	// The instance ID. InstanceId has been deprecated. To specify an instance ID for
	// an association, use the Targets parameter. Requests that include the parameter
	// InstanceID with SSM documents that use schema version 2.0 or later will fail. In
	// addition, if you use the parameter InstanceId, you cannot use the parameters
	// AssociationName, DocumentVersion, MaxErrors, MaxConcurrency, OutputLocation, or
	// ScheduleExpression. To use these parameters, you must use the Targets parameter.
	InstanceId *string

	// The maximum number of targets allowed to run the association at the same time.
	// You can specify a number, for example 10, or a percentage of the target set, for
	// example 10%. The default value is 100%, which means all targets run the
	// association at the same time. If a new instance starts and attempts to run an
	// association while Systems Manager is running MaxConcurrency associations, the
	// association is allowed to run. During the next association interval, the new
	// instance will process its association within the limit specified for
	// MaxConcurrency.
	MaxConcurrency *string

	// The number of errors that are allowed before the system stops sending requests
	// to run the association on additional targets. You can specify either an absolute
	// number of errors, for example 10, or a percentage of the target set, for example
	// 10%. If you specify 3, for example, the system stops sending requests when the
	// fourth error is received. If you specify 0, then the system stops sending
	// requests after the first error is returned. If you run an association on 50
	// instances and set MaxError to 10%, then the system stops sending the request
	// when the sixth error is received. Executions that are already running an
	// association when MaxErrors is reached are allowed to complete, but some of these
	// executions may fail as well. If you need to ensure that there won't be more than
	// max-errors failed executions, set MaxConcurrency to 1 so that executions proceed
	// one at a time.
	MaxErrors *string

	// An S3 bucket where you want to store the output details of the request.
	OutputLocation *types.InstanceAssociationOutputLocation

	// The parameters for the runtime configuration of the document.
	Parameters map[string][]string

	// A cron expression when the association will be applied to the target(s).
	ScheduleExpression *string

	// The mode for generating association compliance. You can specify AUTO or MANUAL.
	// In AUTO mode, the system uses the status of the association execution to
	// determine the compliance status. If the association execution runs successfully,
	// then the association is COMPLIANT. If the association execution doesn't run
	// successfully, the association is NON-COMPLIANT. In MANUAL mode, you must specify
	// the AssociationId as a parameter for the PutComplianceItems API action. In this
	// case, compliance data is not managed by State Manager. It is managed by your
	// direct call to the PutComplianceItems API action. By default, all associations
	// use AUTO mode.
	SyncCompliance types.AssociationSyncCompliance

	// A location is a combination of AWS Regions and AWS accounts where you want to
	// run the association. Use this action to create an association in multiple
	// Regions and multiple accounts.
	TargetLocations []types.TargetLocation

	// The targets for the association. You can target instances by using tags, AWS
	// Resource Groups, all instances in an AWS account, or individual instance IDs.
	// For more information about choosing targets for an association, see Using
	// targets and rate controls with State Manager associations
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-state-manager-targets-and-rate-controls.html)
	// in the AWS Systems Manager User Guide.
	Targets []types.Target
}

type CreateAssociationOutput struct {

	// Information about the association.
	AssociationDescription *types.AssociationDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateDocumentInput struct {

	// The content for the new SSM document in JSON or YAML format. We recommend
	// storing the contents for your new document in an external JSON or YAML file and
	// referencing the file in a command. For examples, see the following topics in the
	// AWS Systems Manager User Guide.
	//
	// * Create an SSM document (AWS API)
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/create-ssm-document-api.html)
	//
	// *
	// Create an SSM document (AWS CLI)
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/create-ssm-document-cli.html)
	//
	// *
	// Create an SSM document (API)
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/create-ssm-document-api.html)
	//
	// This member is required.
	Content *string

	// A name for the Systems Manager document. You can't use the following strings as
	// document name prefixes. These are reserved by AWS for use as document name
	// prefixes:
	//
	// * aws-
	//
	// * amazon
	//
	// * amzn
	//
	// This member is required.
	Name *string

	// A list of key and value pairs that describe attachments to a version of a
	// document.
	Attachments []types.AttachmentsSource

	// Specify the document format for the request. The document format can be JSON,
	// YAML, or TEXT. JSON is the default format.
	DocumentFormat types.DocumentFormat

	// The type of document to create.
	DocumentType types.DocumentType

	// A list of SSM documents required by a document. This parameter is used
	// exclusively by AWS AppConfig. When a user creates an AppConfig configuration in
	// an SSM document, the user must also specify a required document for validation
	// purposes. In this case, an ApplicationConfiguration document requires an
	// ApplicationConfigurationSchema document for validation purposes. For more
	// information, see AWS AppConfig
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig.html) in
	// the AWS Systems Manager User Guide.
	Requires []types.DocumentRequires

	// Optional metadata that you assign to a resource. Tags enable you to categorize a
	// resource in different ways, such as by purpose, owner, or environment. For
	// example, you might want to tag an SSM document to identify the types of targets
	// or the environment where it will run. In this case, you could specify the
	// following key name/value pairs:
	//
	// * Key=OS,Value=Windows
	//
	// *
	// Key=Environment,Value=Production
	//
	// To add tags to an existing SSM document, use
	// the AddTagsToResource action.
	Tags []types.Tag

	// Specify a target type to define the kinds of resources the document can run on.
	// For example, to run a document on EC2 instances, specify the following value:
	// /AWS::EC2::Instance. If you specify a value of '/' the document can run on all
	// types of resources. If you don't specify a value, the document can't run on any
	// resources. For a list of valid resource types, see AWS resource and property
	// types reference
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
	// in the AWS CloudFormation User Guide.
	TargetType *string

	// An optional field specifying the version of the artifact you are creating with
	// the document. For example, "Release 12, Update 6". This value is unique across
	// all versions of a document, and cannot be changed.
	VersionName *string
}

type CreateDocumentOutput struct {

	// Information about the Systems Manager document.
	DocumentDescription *types.DocumentDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateMaintenanceWindowInput struct {

	// Enables a maintenance window task to run on managed instances, even if you have
	// not registered those instances as targets. If enabled, then you must specify the
	// unregistered instances (by instance ID) when you register a task with the
	// maintenance window. If you don't enable this option, then you must specify
	// previously-registered targets when you register a task with the maintenance
	// window.
	//
	// This member is required.
	AllowUnassociatedTargets bool

	// The number of hours before the end of the maintenance window that Systems
	// Manager stops scheduling new tasks for execution.
	//
	// This member is required.
	Cutoff int32

	// The duration of the maintenance window in hours.
	//
	// This member is required.
	Duration int32

	// The name of the maintenance window.
	//
	// This member is required.
	Name *string

	// The schedule of the maintenance window in the form of a cron or rate expression.
	//
	// This member is required.
	Schedule *string

	// User-provided idempotency token.
	ClientToken *string

	// An optional description for the maintenance window. We recommend specifying a
	// description to help you organize your maintenance windows.
	Description *string

	// The date and time, in ISO-8601 Extended format, for when you want the
	// maintenance window to become inactive. EndDate allows you to set a date and time
	// in the future when the maintenance window will no longer run.
	EndDate *string

	// The number of days to wait after the date and time specified by a CRON
	// expression before running the maintenance window. For example, the following
	// cron expression schedules a maintenance window to run on the third Tuesday of
	// every month at 11:30 PM. cron(30 23 ? * TUE#3 *) If the schedule offset is 2,
	// the maintenance window won't run until two days later.
	ScheduleOffset int32

	// The time zone that the scheduled maintenance window executions are based on, in
	// Internet Assigned Numbers Authority (IANA) format. For example:
	// "America/Los_Angeles", "UTC", or "Asia/Seoul". For more information, see the
	// Time Zone Database (https://www.iana.org/time-zones) on the IANA website.
	ScheduleTimezone *string

	// The date and time, in ISO-8601 Extended format, for when you want the
	// maintenance window to become active. StartDate allows you to delay activation of
	// the maintenance window until the specified future date.
	StartDate *string

	// Optional metadata that you assign to a resource. Tags enable you to categorize a
	// resource in different ways, such as by purpose, owner, or environment. For
	// example, you might want to tag a maintenance window to identify the type of
	// tasks it will run, the types of targets, and the environment it will run in. In
	// this case, you could specify the following key name/value pairs:
	//
	// *
	// Key=TaskType,Value=AgentUpdate
	//
	// * Key=OS,Value=Windows
	//
	// *
	// Key=Environment,Value=Production
	//
	// To add tags to an existing maintenance window,
	// use the AddTagsToResource action.
	Tags []types.Tag
}

type CreateMaintenanceWindowOutput struct {

	// The ID of the created maintenance window.
	WindowId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateOpsItemInput struct {

	// Information about the OpsItem.
	//
	// This member is required.
	Description *string

	// The origin of the OpsItem, such as Amazon EC2 or Systems Manager. The source
	// name can't contain the following strings: aws, amazon, and amzn.
	//
	// This member is required.
	Source *string

	// A short heading that describes the nature of the OpsItem and the impacted
	// resource.
	//
	// This member is required.
	Title *string

	// The time a runbook workflow ended. Currently reported only for the OpsItem type
	// /aws/changerequest.
	ActualEndTime *time.Time

	// The time a runbook workflow started. Currently reported only for the OpsItem
	// type /aws/changerequest.
	ActualStartTime *time.Time

	// Specify a category to assign to an OpsItem.
	Category *string

	// The Amazon Resource Name (ARN) of an SNS topic where notifications are sent when
	// this OpsItem is edited or changed.
	Notifications []types.OpsItemNotification

	// Operational data is custom data that provides useful reference details about the
	// OpsItem. For example, you can specify log files, error strings, license keys,
	// troubleshooting tips, or other relevant data. You enter operational data as
	// key-value pairs. The key has a maximum length of 128 characters. The value has a
	// maximum size of 20 KB. Operational data keys can't begin with the following:
	// amazon, aws, amzn, ssm, /amazon, /aws, /amzn, /ssm. You can choose to make the
	// data searchable by other users in the account or you can restrict search access.
	// Searchable data means that all users with access to the OpsItem Overview page
	// (as provided by the DescribeOpsItems API action) can view and search on the
	// specified data. Operational data that is not searchable is only viewable by
	// users who have access to the OpsItem (as provided by the GetOpsItem API action).
	// Use the /aws/resources key in OperationalData to specify a related resource in
	// the request. Use the /aws/automations key in OperationalData to associate an
	// Automation runbook with the OpsItem. To view AWS CLI example commands that use
	// these keys, see Creating OpsItems manually
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-creating-OpsItems.html#OpsCenter-manually-create-OpsItems)
	// in the AWS Systems Manager User Guide.
	OperationalData map[string]types.OpsItemDataValue

	// The type of OpsItem to create. Currently, the only valid values are
	// /aws/changerequest and /aws/issue.
	OpsItemType *string

	// The time specified in a change request for a runbook workflow to end. Currently
	// supported only for the OpsItem type /aws/changerequest.
	PlannedEndTime *time.Time

	// The time specified in a change request for a runbook workflow to start.
	// Currently supported only for the OpsItem type /aws/changerequest.
	PlannedStartTime *time.Time

	// The importance of this OpsItem in relation to other OpsItems in the system.
	Priority *int32

	// One or more OpsItems that share something in common with the current OpsItems.
	// For example, related OpsItems can include OpsItems with similar error messages,
	// impacted resources, or statuses for the impacted resource.
	RelatedOpsItems []types.RelatedOpsItem

	// Specify a severity to assign to an OpsItem.
	Severity *string

	// Optional metadata that you assign to a resource. You can restrict access to
	// OpsItems by using an inline IAM policy that specifies tags. For more
	// information, see Getting started with OpsCenter
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-getting-started.html#OpsCenter-getting-started-user-permissions)
	// in the AWS Systems Manager User Guide. Tags use a key-value pair. For example:
	// Key=Department,Value=Finance To add tags to an existing OpsItem, use the
	// AddTagsToResource action.
	Tags []types.Tag
}

type CreateOpsItemOutput struct {

	// The ID of the OpsItem.
	OpsItemId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateOpsMetadataInput struct {

	// A resource ID for a new Application Manager application.
	//
	// This member is required.
	ResourceId *string

	// Metadata for a new Application Manager application.
	Metadata map[string]types.MetadataValue
}

type CreateOpsMetadataOutput struct {

	// The Amazon Resource Name (ARN) of the OpsMetadata Object or blob created by the
	// call.
	OpsMetadataArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreatePatchBaselineInput struct {

	// The name of the patch baseline.
	//
	// This member is required.
	Name *string

	// A set of rules used to include patches in the baseline.
	ApprovalRules *types.PatchRuleGroup

	// A list of explicitly approved patches for the baseline. For information about
	// accepted formats for lists of approved patches and rejected patches, see About
	// package name formats for approved and rejected patch lists
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/patch-manager-approved-rejected-package-name-formats.html)
	// in the AWS Systems Manager User Guide.
	ApprovedPatches []string

	// Defines the compliance level for approved patches. This means that if an
	// approved patch is reported as missing, this is the severity of the compliance
	// violation. The default value is UNSPECIFIED.
	ApprovedPatchesComplianceLevel types.PatchComplianceLevel

	// Indicates whether the list of approved patches includes non-security updates
	// that should be applied to the instances. The default value is 'false'. Applies
	// to Linux instances only.
	ApprovedPatchesEnableNonSecurity bool

	// User-provided idempotency token.
	ClientToken *string

	// A description of the patch baseline.
	Description *string

	// A set of global filters used to include patches in the baseline.
	GlobalFilters *types.PatchFilterGroup

	// Defines the operating system the patch baseline applies to. The Default value is
	// WINDOWS.
	OperatingSystem types.OperatingSystem

	// A list of explicitly rejected patches for the baseline. For information about
	// accepted formats for lists of approved patches and rejected patches, see About
	// package name formats for approved and rejected patch lists
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/patch-manager-approved-rejected-package-name-formats.html)
	// in the AWS Systems Manager User Guide.
	RejectedPatches []string

	// The action for Patch Manager to take on patches included in the RejectedPackages
	// list.
	//
	// * ALLOW_AS_DEPENDENCY: A package in the Rejected patches list is
	// installed only if it is a dependency of another package. It is considered
	// compliant with the patch baseline, and its status is reported as InstalledOther.
	// This is the default action if no option is specified.
	//
	// * BLOCK: Packages in the
	// RejectedPatches list, and packages that include them as dependencies, are not
	// installed under any circumstances. If a package was installed before it was
	// added to the Rejected patches list, it is considered non-compliant with the
	// patch baseline, and its status is reported as InstalledRejected.
	RejectedPatchesAction types.PatchAction

	// Information about the patches to use to update the instances, including target
	// operating systems and source repositories. Applies to Linux instances only.
	Sources []types.PatchSource

	// Optional metadata that you assign to a resource. Tags enable you to categorize a
	// resource in different ways, such as by purpose, owner, or environment. For
	// example, you might want to tag a patch baseline to identify the severity level
	// of patches it specifies and the operating system family it applies to. In this
	// case, you could specify the following key name/value pairs:
	//
	// *
	// Key=PatchSeverity,Value=Critical
	//
	// * Key=OS,Value=Windows
	//
	// To add tags to an
	// existing patch baseline, use the AddTagsToResource action.
	Tags []types.Tag
}

type CreatePatchBaselineOutput struct {

	// The ID of the created patch baseline.
	BaselineId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateResourceDataSyncInput struct {

	// A name for the configuration.
	//
	// This member is required.
	SyncName *string

	// Amazon S3 configuration details for the sync. This parameter is required if the
	// SyncType value is SyncToDestination.
	S3Destination *types.ResourceDataSyncS3Destination

	// Specify information about the data sources to synchronize. This parameter is
	// required if the SyncType value is SyncFromSource.
	SyncSource *types.ResourceDataSyncSource

	// Specify SyncToDestination to create a resource data sync that synchronizes data
	// to an S3 bucket for Inventory. If you specify SyncToDestination, you must
	// provide a value for S3Destination. Specify SyncFromSource to synchronize data
	// from a single account and multiple Regions, or multiple AWS accounts and
	// Regions, as listed in AWS Organizations for Explorer. If you specify
	// SyncFromSource, you must provide a value for SyncSource. The default value is
	// SyncToDestination.
	SyncType *string
}

type CreateResourceDataSyncOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteActivationInput struct {

	// The ID of the activation that you want to delete.
	//
	// This member is required.
	ActivationId *string
}

type DeleteActivationOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteAssociationInput struct {

	// The association ID that you want to delete.
	AssociationId *string

	// The ID of the instance.
	InstanceId *string

	// The name of the Systems Manager document.
	Name *string
}

type DeleteAssociationOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteDocumentInput struct {

	// The name of the document.
	//
	// This member is required.
	Name *string

	// The version of the document that you want to delete. If not provided, all
	// versions of the document are deleted.
	DocumentVersion *string

	// Some SSM document types require that you specify a Force flag before you can
	// delete the document. For example, you must specify a Force flag to delete a
	// document of type ApplicationConfigurationSchema. You can restrict access to the
	// Force flag in an AWS Identity and Access Management (IAM) policy.
	Force bool

	// The version name of the document that you want to delete. If not provided, all
	// versions of the document are deleted.
	VersionName *string
}

type DeleteDocumentOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteInventoryInput struct {

	// The name of the custom inventory type for which you want to delete either all
	// previously collected data or the inventory type itself.
	//
	// This member is required.
	TypeName *string

	// User-provided idempotency token.
	ClientToken *string

	// Use this option to view a summary of the deletion request without deleting any
	// data or the data type. This option is useful when you only want to understand
	// what will be deleted. Once you validate that the data to be deleted is what you
	// intend to delete, you can run the same command without specifying the DryRun
	// option.
	DryRun bool

	// Use the SchemaDeleteOption to delete a custom inventory type (schema). If you
	// don't choose this option, the system only deletes existing inventory data
	// associated with the custom inventory type. Choose one of the following options:
	// DisableSchema: If you choose this option, the system ignores all inventory data
	// for the specified version, and any earlier versions. To enable this schema
	// again, you must call the PutInventory action for a version greater than the
	// disabled version. DeleteSchema: This option deletes the specified custom type
	// from the Inventory service. You can recreate the schema later, if you want.
	SchemaDeleteOption types.InventorySchemaDeleteOption
}

type DeleteInventoryOutput struct {

	// Every DeleteInventory action is assigned a unique ID. This option returns a
	// unique ID. You can use this ID to query the status of a delete operation. This
	// option is useful for ensuring that a delete operation has completed before you
	// begin other actions.
	DeletionId *string

	// A summary of the delete operation. For more information about this summary, see
	// Deleting custom inventory
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-inventory-custom.html#sysman-inventory-delete-summary)
	// in the AWS Systems Manager User Guide.
	DeletionSummary *types.InventoryDeletionSummary

	// The name of the inventory data type specified in the request.
	TypeName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteMaintenanceWindowInput struct {

	// The ID of the maintenance window to delete.
	//
	// This member is required.
	WindowId *string
}

type DeleteMaintenanceWindowOutput struct {

	// The ID of the deleted maintenance window.
	WindowId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteOpsMetadataInput struct {

	// The Amazon Resource Name (ARN) of an OpsMetadata Object to delete.
	//
	// This member is required.
	OpsMetadataArn *string
}

type DeleteOpsMetadataOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteParameterInput struct {

	// The name of the parameter to delete.
	//
	// This member is required.
	Name *string
}

type DeleteParameterOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteParametersInput struct {

	// The names of the parameters to delete.
	//
	// This member is required.
	Names []string
}

type DeleteParametersOutput struct {

	// The names of the deleted parameters.
	DeletedParameters []string

	// The names of parameters that weren't deleted because the parameters are not
	// valid.
	InvalidParameters []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeletePatchBaselineInput struct {

	// The ID of the patch baseline to delete.
	//
	// This member is required.
	BaselineId *string
}

type DeletePatchBaselineOutput struct {

	// The ID of the deleted patch baseline.
	BaselineId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteResourceDataSyncInput struct {

	// The name of the configuration to delete.
	//
	// This member is required.
	SyncName *string

	// Specify the type of resource data sync to delete.
	SyncType *string
}

type DeleteResourceDataSyncOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterManagedInstanceInput struct {

	// The ID assigned to the managed instance when you registered it using the
	// activation process.
	//
	// This member is required.
	InstanceId *string
}

type DeregisterManagedInstanceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterPatchBaselineForPatchGroupInput struct {

	// The ID of the patch baseline to deregister the patch group from.
	//
	// This member is required.
	BaselineId *string

	// The name of the patch group that should be deregistered from the patch baseline.
	//
	// This member is required.
	PatchGroup *string
}

type DeregisterPatchBaselineForPatchGroupOutput struct {

	// The ID of the patch baseline the patch group was deregistered from.
	BaselineId *string

	// The name of the patch group deregistered from the patch baseline.
	PatchGroup *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterTargetFromMaintenanceWindowInput struct {

	// The ID of the maintenance window the target should be removed from.
	//
	// This member is required.
	WindowId *string

	// The ID of the target definition to remove.
	//
	// This member is required.
	WindowTargetId *string

	// The system checks if the target is being referenced by a task. If the target is
	// being referenced, the system returns an error and does not deregister the target
	// from the maintenance window.
	Safe bool
}

type DeregisterTargetFromMaintenanceWindowOutput struct {

	// The ID of the maintenance window the target was removed from.
	WindowId *string

	// The ID of the removed target definition.
	WindowTargetId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterTaskFromMaintenanceWindowInput struct {

	// The ID of the maintenance window the task should be removed from.
	//
	// This member is required.
	WindowId *string

	// The ID of the task to remove from the maintenance window.
	//
	// This member is required.
	WindowTaskId *string
}

type DeregisterTaskFromMaintenanceWindowOutput struct {

	// The ID of the maintenance window the task was removed from.
	WindowId *string

	// The ID of the task removed from the maintenance window.
	WindowTaskId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeActivationsAPIClient interface {
	DescribeActivations(context.Context, *DescribeActivationsInput, ...func(*Options)) (*DescribeActivationsOutput, error)
}

type DescribeActivationsInput struct {

	// A filter to view information about your activations.
	Filters []types.DescribeActivationsFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string
}

type DescribeActivationsOutput struct {

	// A list of activations for your AWS account.
	ActivationList []types.Activation

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeActivationsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeActivationsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeAssociationExecutionTargetsAPIClient interface {
	DescribeAssociationExecutionTargets(context.Context, *DescribeAssociationExecutionTargetsInput, ...func(*Options)) (*DescribeAssociationExecutionTargetsOutput, error)
}

type DescribeAssociationExecutionTargetsInput struct {

	// The association ID that includes the execution for which you want to view
	// details.
	//
	// This member is required.
	AssociationId *string

	// The execution ID for which you want to view details.
	//
	// This member is required.
	ExecutionId *string

	// Filters for the request. You can specify the following filters and values.
	// Status (EQUAL) ResourceId (EQUAL) ResourceType (EQUAL)
	Filters []types.AssociationExecutionTargetsFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string
}

type DescribeAssociationExecutionTargetsOutput struct {

	// Information about the execution.
	AssociationExecutionTargets []types.AssociationExecutionTarget

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAssociationExecutionTargetsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeAssociationExecutionTargetsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeAssociationExecutionsAPIClient interface {
	DescribeAssociationExecutions(context.Context, *DescribeAssociationExecutionsInput, ...func(*Options)) (*DescribeAssociationExecutionsOutput, error)
}

type DescribeAssociationExecutionsInput struct {

	// The association ID for which you want to view execution history details.
	//
	// This member is required.
	AssociationId *string

	// Filters for the request. You can specify the following filters and values.
	// ExecutionId (EQUAL) Status (EQUAL) CreatedTime (EQUAL, GREATER_THAN, LESS_THAN)
	Filters []types.AssociationExecutionFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string
}

type DescribeAssociationExecutionsOutput struct {

	// A list of the executions for the specified association ID.
	AssociationExecutions []types.AssociationExecution

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAssociationExecutionsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeAssociationExecutionsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeAssociationInput struct {

	// The association ID for which you want information.
	AssociationId *string

	// Specify the association version to retrieve. To view the latest version, either
	// specify $LATEST for this parameter, or omit this parameter. To view a list of
	// all associations for an instance, use ListAssociations. To get a list of
	// versions for a specific association, use ListAssociationVersions.
	AssociationVersion *string

	// The instance ID.
	InstanceId *string

	// The name of the Systems Manager document.
	Name *string
}

type DescribeAssociationOutput struct {

	// Information about the association.
	AssociationDescription *types.AssociationDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAutomationExecutionsAPIClient interface {
	DescribeAutomationExecutions(context.Context, *DescribeAutomationExecutionsInput, ...func(*Options)) (*DescribeAutomationExecutionsOutput, error)
}

type DescribeAutomationExecutionsInput struct {

	// Filters used to limit the scope of executions that are requested.
	Filters []types.AutomationExecutionFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeAutomationExecutionsOutput struct {

	// The list of details about each automation execution which has occurred which
	// matches the filter specification, if any.
	AutomationExecutionMetadataList []types.AutomationExecutionMetadata

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAutomationExecutionsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeAutomationExecutionsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeAutomationStepExecutionsAPIClient interface {
	DescribeAutomationStepExecutions(context.Context, *DescribeAutomationStepExecutionsInput, ...func(*Options)) (*DescribeAutomationStepExecutionsOutput, error)
}

type DescribeAutomationStepExecutionsInput struct {

	// The Automation execution ID for which you want step execution descriptions.
	//
	// This member is required.
	AutomationExecutionId *string

	// One or more filters to limit the number of step executions returned by the
	// request.
	Filters []types.StepExecutionFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// A boolean that indicates whether to list step executions in reverse order by
	// start time. The default value is false.
	ReverseOrder bool
}

type DescribeAutomationStepExecutionsOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// A list of details about the current state of all steps that make up an
	// execution.
	StepExecutions []types.StepExecution

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAutomationStepExecutionsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeAutomationStepExecutionsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeAvailablePatchesAPIClient interface {
	DescribeAvailablePatches(context.Context, *DescribeAvailablePatchesInput, ...func(*Options)) (*DescribeAvailablePatchesOutput, error)
}

type DescribeAvailablePatchesInput struct {

	// Filters used to scope down the returned patches.
	Filters []types.PatchOrchestratorFilter

	// The maximum number of patches to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeAvailablePatchesOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// An array of patches. Each entry in the array is a patch structure.
	Patches []types.Patch

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAvailablePatchesPaginator struct {
	// contains filtered or unexported fields
}

type DescribeAvailablePatchesPaginatorOptions struct {
	// The maximum number of patches to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeDocumentInput struct {

	// The name of the Systems Manager document.
	//
	// This member is required.
	Name *string

	// The document version for which you want information. Can be a specific version
	// or the default version.
	DocumentVersion *string

	// An optional field specifying the version of the artifact associated with the
	// document. For example, "Release 12, Update 6". This value is unique across all
	// versions of a document, and cannot be changed.
	VersionName *string
}

type DescribeDocumentOutput struct {

	// Information about the Systems Manager document.
	Document *types.DocumentDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeDocumentPermissionInput struct {

	// The name of the document for which you are the owner.
	//
	// This member is required.
	Name *string

	// The permission type for the document. The permission type can be Share.
	//
	// This member is required.
	PermissionType types.DocumentPermissionType
}

type DescribeDocumentPermissionOutput struct {

	// The account IDs that have permission to use this document. The ID can be either
	// an AWS account or All.
	AccountIds []string

	// A list of AWS accounts where the current document is shared and the version
	// shared with each account.
	AccountSharingInfoList []types.AccountSharingInfo

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEffectiveInstanceAssociationsAPIClient interface {
	DescribeEffectiveInstanceAssociations(context.Context, *DescribeEffectiveInstanceAssociationsInput, ...func(*Options)) (*DescribeEffectiveInstanceAssociationsOutput, error)
}

type DescribeEffectiveInstanceAssociationsInput struct {

	// The instance ID for which you want to view all associations.
	//
	// This member is required.
	InstanceId *string

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeEffectiveInstanceAssociationsOutput struct {

	// The associations for the requested instance.
	Associations []types.InstanceAssociation

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEffectiveInstanceAssociationsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeEffectiveInstanceAssociationsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeEffectivePatchesForPatchBaselineAPIClient interface {
	DescribeEffectivePatchesForPatchBaseline(context.Context, *DescribeEffectivePatchesForPatchBaselineInput, ...func(*Options)) (*DescribeEffectivePatchesForPatchBaselineOutput, error)
}

type DescribeEffectivePatchesForPatchBaselineInput struct {

	// The ID of the patch baseline to retrieve the effective patches for.
	//
	// This member is required.
	BaselineId *string

	// The maximum number of patches to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeEffectivePatchesForPatchBaselineOutput struct {

	// An array of patches and patch status.
	EffectivePatches []types.EffectivePatch

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEffectivePatchesForPatchBaselinePaginator struct {
	// contains filtered or unexported fields
}

type DescribeEffectivePatchesForPatchBaselinePaginatorOptions struct {
	// The maximum number of patches to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeInstanceAssociationsStatusAPIClient interface {
	DescribeInstanceAssociationsStatus(context.Context, *DescribeInstanceAssociationsStatusInput, ...func(*Options)) (*DescribeInstanceAssociationsStatusOutput, error)
}

type DescribeInstanceAssociationsStatusInput struct {

	// The instance IDs for which you want association status information.
	//
	// This member is required.
	InstanceId *string

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeInstanceAssociationsStatusOutput struct {

	// Status information about the association.
	InstanceAssociationStatusInfos []types.InstanceAssociationStatusInfo

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInstanceAssociationsStatusPaginator struct {
	// contains filtered or unexported fields
}

type DescribeInstanceAssociationsStatusPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeInstanceInformationAPIClient interface {
	DescribeInstanceInformation(context.Context, *DescribeInstanceInformationInput, ...func(*Options)) (*DescribeInstanceInformationOutput, error)
}

type DescribeInstanceInformationInput struct {

	// One or more filters. Use a filter to return a more specific list of instances.
	// You can filter based on tags applied to EC2 instances. Use this Filters data
	// type instead of InstanceInformationFilterList, which is deprecated.
	Filters []types.InstanceInformationStringFilter

	// This is a legacy method. We recommend that you don't use this method. Instead,
	// use the Filters data type. Filters enables you to return instance information by
	// filtering based on tags applied to managed instances. Attempting to use
	// InstanceInformationFilterList and Filters leads to an exception error.
	InstanceInformationFilterList []types.InstanceInformationFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeInstanceInformationOutput struct {

	// The instance information list.
	InstanceInformationList []types.InstanceInformation

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInstanceInformationPaginator struct {
	// contains filtered or unexported fields
}

type DescribeInstanceInformationPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeInstancePatchStatesAPIClient interface {
	DescribeInstancePatchStates(context.Context, *DescribeInstancePatchStatesInput, ...func(*Options)) (*DescribeInstancePatchStatesOutput, error)
}

type DescribeInstancePatchStatesForPatchGroupAPIClient interface {
	DescribeInstancePatchStatesForPatchGroup(context.Context, *DescribeInstancePatchStatesForPatchGroupInput, ...func(*Options)) (*DescribeInstancePatchStatesForPatchGroupOutput, error)
}

type DescribeInstancePatchStatesForPatchGroupInput struct {

	// The name of the patch group for which the patch state information should be
	// retrieved.
	//
	// This member is required.
	PatchGroup *string

	// Each entry in the array is a structure containing: Key (string between 1 and 200
	// characters) Values (array containing a single string) Type (string "Equal",
	// "NotEqual", "LessThan", "GreaterThan")
	Filters []types.InstancePatchStateFilter

	// The maximum number of patches to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeInstancePatchStatesForPatchGroupOutput struct {

	// The high-level patch state for the requested instances.
	InstancePatchStates []types.InstancePatchState

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInstancePatchStatesForPatchGroupPaginator struct {
	// contains filtered or unexported fields
}

type DescribeInstancePatchStatesForPatchGroupPaginatorOptions struct {
	// The maximum number of patches to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeInstancePatchStatesInput struct {

	// The ID of the instance whose patch state information should be retrieved.
	//
	// This member is required.
	InstanceIds []string

	// The maximum number of instances to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeInstancePatchStatesOutput struct {

	// The high-level patch state for the requested instances.
	InstancePatchStates []types.InstancePatchState

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInstancePatchStatesPaginator struct {
	// contains filtered or unexported fields
}

type DescribeInstancePatchStatesPaginatorOptions struct {
	// The maximum number of instances to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeInstancePatchesAPIClient interface {
	DescribeInstancePatches(context.Context, *DescribeInstancePatchesInput, ...func(*Options)) (*DescribeInstancePatchesOutput, error)
}

type DescribeInstancePatchesInput struct {

	// The ID of the instance whose patch state information should be retrieved.
	//
	// This member is required.
	InstanceId *string

	// An array of structures. Each entry in the array is a structure containing a Key,
	// Value combination. Valid values for Key are Classification | KBId | Severity |
	// State.
	Filters []types.PatchOrchestratorFilter

	// The maximum number of patches to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeInstancePatchesOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Each entry in the array is a structure containing: Title (string) KBId (string)
	// Classification (string) Severity (string) State (string, such as "INSTALLED" or
	// "FAILED") InstalledTime (DateTime) InstalledBy (string)
	Patches []types.PatchComplianceData

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInstancePatchesPaginator struct {
	// contains filtered or unexported fields
}

type DescribeInstancePatchesPaginatorOptions struct {
	// The maximum number of patches to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeInventoryDeletionsAPIClient interface {
	DescribeInventoryDeletions(context.Context, *DescribeInventoryDeletionsInput, ...func(*Options)) (*DescribeInventoryDeletionsOutput, error)
}

type DescribeInventoryDeletionsInput struct {

	// Specify the delete inventory ID for which you want information. This ID was
	// returned by the DeleteInventory action.
	DeletionId *string

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string
}

type DescribeInventoryDeletionsOutput struct {

	// A list of status items for deleted inventory.
	InventoryDeletions []types.InventoryDeletionStatusItem

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInventoryDeletionsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeInventoryDeletionsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowExecutionTaskInvocationsAPIClient interface {
	DescribeMaintenanceWindowExecutionTaskInvocations(context.Context, *DescribeMaintenanceWindowExecutionTaskInvocationsInput, ...func(*Options)) (*DescribeMaintenanceWindowExecutionTaskInvocationsOutput, error)
}

type DescribeMaintenanceWindowExecutionTaskInvocationsInput struct {

	// The ID of the specific task in the maintenance window task that should be
	// retrieved.
	//
	// This member is required.
	TaskId *string

	// The ID of the maintenance window execution the task is part of.
	//
	// This member is required.
	WindowExecutionId *string

	// Optional filters used to scope down the returned task invocations. The supported
	// filter key is STATUS with the corresponding values PENDING, IN_PROGRESS,
	// SUCCESS, FAILED, TIMED_OUT, CANCELLING, and CANCELLED.
	Filters []types.MaintenanceWindowFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowExecutionTaskInvocationsOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Information about the task invocation results per invocation.
	WindowExecutionTaskInvocationIdentities []types.MaintenanceWindowExecutionTaskInvocationIdentity

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowExecutionTaskInvocationsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowExecutionTaskInvocationsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowExecutionTasksAPIClient interface {
	DescribeMaintenanceWindowExecutionTasks(context.Context, *DescribeMaintenanceWindowExecutionTasksInput, ...func(*Options)) (*DescribeMaintenanceWindowExecutionTasksOutput, error)
}

type DescribeMaintenanceWindowExecutionTasksInput struct {

	// The ID of the maintenance window execution whose task executions should be
	// retrieved.
	//
	// This member is required.
	WindowExecutionId *string

	// Optional filters used to scope down the returned tasks. The supported filter key
	// is STATUS with the corresponding values PENDING, IN_PROGRESS, SUCCESS, FAILED,
	// TIMED_OUT, CANCELLING, and CANCELLED.
	Filters []types.MaintenanceWindowFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowExecutionTasksOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Information about the task executions.
	WindowExecutionTaskIdentities []types.MaintenanceWindowExecutionTaskIdentity

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowExecutionTasksPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowExecutionTasksPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowExecutionsAPIClient interface {
	DescribeMaintenanceWindowExecutions(context.Context, *DescribeMaintenanceWindowExecutionsInput, ...func(*Options)) (*DescribeMaintenanceWindowExecutionsOutput, error)
}

type DescribeMaintenanceWindowExecutionsInput struct {

	// The ID of the maintenance window whose executions should be retrieved.
	//
	// This member is required.
	WindowId *string

	// Each entry in the array is a structure containing: Key (string, between 1 and
	// 128 characters) Values (array of strings, each string is between 1 and 256
	// characters) The supported Keys are ExecutedBefore and ExecutedAfter with the
	// value being a date/time string such as 2016-11-04T05:00:00Z.
	Filters []types.MaintenanceWindowFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowExecutionsOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Information about the maintenance window executions.
	WindowExecutions []types.MaintenanceWindowExecution

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowExecutionsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowExecutionsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowScheduleAPIClient interface {
	DescribeMaintenanceWindowSchedule(context.Context, *DescribeMaintenanceWindowScheduleInput, ...func(*Options)) (*DescribeMaintenanceWindowScheduleOutput, error)
}

type DescribeMaintenanceWindowScheduleInput struct {

	// Filters used to limit the range of results. For example, you can limit
	// maintenance window executions to only those scheduled before or after a certain
	// date and time.
	Filters []types.PatchOrchestratorFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// The type of resource you want to retrieve information about. For example,
	// "INSTANCE".
	ResourceType types.MaintenanceWindowResourceType

	// The instance ID or key/value pair to retrieve information about.
	Targets []types.Target

	// The ID of the maintenance window to retrieve information about.
	WindowId *string
}

type DescribeMaintenanceWindowScheduleOutput struct {

	// The token for the next set of items to return. (You use this token in the next
	// call.)
	NextToken *string

	// Information about maintenance window executions scheduled for the specified time
	// range.
	ScheduledWindowExecutions []types.ScheduledWindowExecution

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowSchedulePaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowSchedulePaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowTargetsAPIClient interface {
	DescribeMaintenanceWindowTargets(context.Context, *DescribeMaintenanceWindowTargetsInput, ...func(*Options)) (*DescribeMaintenanceWindowTargetsOutput, error)
}

type DescribeMaintenanceWindowTargetsInput struct {

	// The ID of the maintenance window whose targets should be retrieved.
	//
	// This member is required.
	WindowId *string

	// Optional filters that can be used to narrow down the scope of the returned
	// window targets. The supported filter keys are Type, WindowTargetId and
	// OwnerInformation.
	Filters []types.MaintenanceWindowFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowTargetsOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Information about the targets in the maintenance window.
	Targets []types.MaintenanceWindowTarget

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowTargetsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowTargetsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowTasksAPIClient interface {
	DescribeMaintenanceWindowTasks(context.Context, *DescribeMaintenanceWindowTasksInput, ...func(*Options)) (*DescribeMaintenanceWindowTasksOutput, error)
}

type DescribeMaintenanceWindowTasksInput struct {

	// The ID of the maintenance window whose tasks should be retrieved.
	//
	// This member is required.
	WindowId *string

	// Optional filters used to narrow down the scope of the returned tasks. The
	// supported filter keys are WindowTaskId, TaskArn, Priority, and TaskType.
	Filters []types.MaintenanceWindowFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowTasksOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Information about the tasks in the maintenance window.
	Tasks []types.MaintenanceWindowTask

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowTasksPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowTasksPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowsAPIClient interface {
	DescribeMaintenanceWindows(context.Context, *DescribeMaintenanceWindowsInput, ...func(*Options)) (*DescribeMaintenanceWindowsOutput, error)
}

type DescribeMaintenanceWindowsForTargetAPIClient interface {
	DescribeMaintenanceWindowsForTarget(context.Context, *DescribeMaintenanceWindowsForTargetInput, ...func(*Options)) (*DescribeMaintenanceWindowsForTargetOutput, error)
}

type DescribeMaintenanceWindowsForTargetInput struct {

	// The type of resource you want to retrieve information about. For example,
	// "INSTANCE".
	//
	// This member is required.
	ResourceType types.MaintenanceWindowResourceType

	// The instance ID or key/value pair to retrieve information about.
	//
	// This member is required.
	Targets []types.Target

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowsForTargetOutput struct {

	// The token for the next set of items to return. (You use this token in the next
	// call.)
	NextToken *string

	// Information about the maintenance window targets and tasks an instance is
	// associated with.
	WindowIdentities []types.MaintenanceWindowIdentityForTarget

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowsForTargetPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowsForTargetPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeMaintenanceWindowsInput struct {

	// Optional filters used to narrow down the scope of the returned maintenance
	// windows. Supported filter keys are Name and Enabled.
	Filters []types.MaintenanceWindowFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeMaintenanceWindowsOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Information about the maintenance windows.
	WindowIdentities []types.MaintenanceWindowIdentity

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMaintenanceWindowsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeMaintenanceWindowsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeOpsItemsAPIClient interface {
	DescribeOpsItems(context.Context, *DescribeOpsItemsInput, ...func(*Options)) (*DescribeOpsItemsOutput, error)
}

type DescribeOpsItemsInput struct {

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults *int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string

	// One or more filters to limit the response.
	//
	// * Key: CreatedTime Operations:
	// GreaterThan, LessThan
	//
	// * Key: LastModifiedBy Operations: Contains, Equals
	//
	// *
	// Key: LastModifiedTime Operations: GreaterThan, LessThan
	//
	// * Key: Priority
	// Operations: Equals
	//
	// * Key: Source Operations: Contains, Equals
	//
	// * Key: Status
	// Operations: Equals
	//
	// * Key: Title Operations: Contains
	//
	// * Key: OperationalData*
	// Operations: Equals
	//
	// * Key: OperationalDataKey Operations: Equals
	//
	// * Key:
	// OperationalDataValue Operations: Equals, Contains
	//
	// * Key: OpsItemId Operations:
	// Equals
	//
	// * Key: ResourceId Operations: Contains
	//
	// * Key: AutomationId Operations:
	// Equals
	//
	// *If you filter the response by using the OperationalData operator,
	// specify a key-value pair by using the following JSON format:
	// {"key":"key_name","value":"a_value"}
	OpsItemFilters []types.OpsItemFilter
}

type DescribeOpsItemsOutput struct {

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// A list of OpsItems.
	OpsItemSummaries []types.OpsItemSummary

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeOpsItemsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeOpsItemsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeParametersAPIClient interface {
	DescribeParameters(context.Context, *DescribeParametersInput, ...func(*Options)) (*DescribeParametersOutput, error)
}

type DescribeParametersInput struct {

	// This data type is deprecated. Instead, use ParameterFilters.
	Filters []types.ParametersFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// Filters to limit the request results.
	ParameterFilters []types.ParameterStringFilter
}

type DescribeParametersOutput struct {

	// The token to use when requesting the next set of items.
	NextToken *string

	// Parameters returned by the request.
	Parameters []types.ParameterMetadata

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeParametersPaginator struct {
	// contains filtered or unexported fields
}

type DescribeParametersPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribePatchBaselinesAPIClient interface {
	DescribePatchBaselines(context.Context, *DescribePatchBaselinesInput, ...func(*Options)) (*DescribePatchBaselinesOutput, error)
}

type DescribePatchBaselinesInput struct {

	// Each element in the array is a structure containing: Key: (string, "NAME_PREFIX"
	// or "OWNER") Value: (array of strings, exactly 1 entry, between 1 and 255
	// characters)
	Filters []types.PatchOrchestratorFilter

	// The maximum number of patch baselines to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribePatchBaselinesOutput struct {

	// An array of PatchBaselineIdentity elements.
	BaselineIdentities []types.PatchBaselineIdentity

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribePatchBaselinesPaginator struct {
	// contains filtered or unexported fields
}

type DescribePatchBaselinesPaginatorOptions struct {
	// The maximum number of patch baselines to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribePatchGroupStateInput struct {

	// The name of the patch group whose patch snapshot should be retrieved.
	//
	// This member is required.
	PatchGroup *string
}

type DescribePatchGroupStateOutput struct {

	// The number of instances in the patch group.
	Instances int32

	// The number of instances with patches from the patch baseline that failed to
	// install.
	InstancesWithFailedPatches int32

	// The number of instances with patches installed that aren't defined in the patch
	// baseline.
	InstancesWithInstalledOtherPatches int32

	// The number of instances with installed patches.
	InstancesWithInstalledPatches int32

	// The number of instances with patches installed by Patch Manager that have not
	// been rebooted after the patch installation. The status of these instances is
	// NON_COMPLIANT.
	InstancesWithInstalledPendingRebootPatches int32

	// The number of instances with patches installed that are specified in a
	// RejectedPatches list. Patches with a status of INSTALLED_REJECTED were typically
	// installed before they were added to a RejectedPatches list. If
	// ALLOW_AS_DEPENDENCY is the specified option for RejectedPatchesAction, the value
	// of InstancesWithInstalledRejectedPatches will always be 0 (zero).
	InstancesWithInstalledRejectedPatches int32

	// The number of instances with missing patches from the patch baseline.
	InstancesWithMissingPatches int32

	// The number of instances with patches that aren't applicable.
	InstancesWithNotApplicablePatches int32

	// The number of instances with NotApplicable patches beyond the supported limit,
	// which are not reported by name to Systems Manager Inventory.
	InstancesWithUnreportedNotApplicablePatches int32

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribePatchGroupsAPIClient interface {
	DescribePatchGroups(context.Context, *DescribePatchGroupsInput, ...func(*Options)) (*DescribePatchGroupsOutput, error)
}

type DescribePatchGroupsInput struct {

	// One or more filters. Use a filter to return a more specific list of results. For
	// DescribePatchGroups,valid filter keys include the following:
	//
	// * NAME_PREFIX: The
	// name of the patch group. Wildcards (*) are accepted.
	//
	// * OPERATING_SYSTEM: The
	// supported operating system type to return results for. For valid operating
	// system values, see GetDefaultPatchBaselineRequest$OperatingSystem in
	// CreatePatchBaseline. Examples:
	//
	// * --filters
	// Key=NAME_PREFIX,Values=MyPatchGroup*
	//
	// * --filters
	// Key=OPERATING_SYSTEM,Values=AMAZON_LINUX_2
	Filters []types.PatchOrchestratorFilter

	// The maximum number of patch groups to return (per page).
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribePatchGroupsOutput struct {

	// Each entry in the array contains: PatchGroup: string (between 1 and 256
	// characters, Regex: ^([\p{L}\p{Z}\p{N}_.:/=+\-@]*)$) PatchBaselineIdentity: A
	// PatchBaselineIdentity element.
	Mappings []types.PatchGroupPatchBaselineMapping

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribePatchGroupsPaginator struct {
	// contains filtered or unexported fields
}

type DescribePatchGroupsPaginatorOptions struct {
	// The maximum number of patch groups to return (per page).
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribePatchPropertiesAPIClient interface {
	DescribePatchProperties(context.Context, *DescribePatchPropertiesInput, ...func(*Options)) (*DescribePatchPropertiesOutput, error)
}

type DescribePatchPropertiesInput struct {

	// The operating system type for which to list patches.
	//
	// This member is required.
	OperatingSystem types.OperatingSystem

	// The patch property for which you want to view patch details.
	//
	// This member is required.
	Property types.PatchProperty

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// Indicates whether to list patches for the Windows operating system or for
	// Microsoft applications. Not applicable for the Linux or macOS operating systems.
	PatchSet types.PatchSet
}

type DescribePatchPropertiesOutput struct {

	// The token for the next set of items to return. (You use this token in the next
	// call.)
	NextToken *string

	// A list of the properties for patches matching the filter request parameters.
	Properties []map[string]string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribePatchPropertiesPaginator struct {
	// contains filtered or unexported fields
}

type DescribePatchPropertiesPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type DescribeSessionsAPIClient interface {
	DescribeSessions(context.Context, *DescribeSessionsInput, ...func(*Options)) (*DescribeSessionsOutput, error)
}

type DescribeSessionsInput struct {

	// The session status to retrieve a list of sessions for. For example, "Active".
	//
	// This member is required.
	State types.SessionState

	// One or more filters to limit the type of sessions returned by the request.
	Filters []types.SessionFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string
}

type DescribeSessionsOutput struct {

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// A list of sessions meeting the request parameters.
	Sessions []types.Session

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeSessionsPaginator struct {
	// contains filtered or unexported fields
}

type DescribeSessionsPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

type EndpointResolverOptions = internalendpoints.Options

type GetAutomationExecutionInput struct {

	// The unique identifier for an existing automation execution to examine. The
	// execution ID is returned by StartAutomationExecution when the execution of an
	// Automation document is initiated.
	//
	// This member is required.
	AutomationExecutionId *string
}

type GetAutomationExecutionOutput struct {

	// Detailed information about the current state of an automation execution.
	AutomationExecution *types.AutomationExecution

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetCalendarStateInput struct {

	// The names or Amazon Resource Names (ARNs) of the Systems Manager documents that
	// represent the calendar entries for which you want to get the state.
	//
	// This member is required.
	CalendarNames []string

	// (Optional) The specific time for which you want to get calendar state
	// information, in ISO 8601 (https://en.wikipedia.org/wiki/ISO_8601) format. If you
	// do not add AtTime, the current time is assumed.
	AtTime *string
}

type GetCalendarStateOutput struct {

	// The time, as an ISO 8601 (https://en.wikipedia.org/wiki/ISO_8601) string, that
	// you specified in your command. If you did not specify a time, GetCalendarState
	// uses the current time.
	AtTime *string

	// The time, as an ISO 8601 (https://en.wikipedia.org/wiki/ISO_8601) string, that
	// the calendar state will change. If the current calendar state is OPEN,
	// NextTransitionTime indicates when the calendar state changes to CLOSED, and
	// vice-versa.
	NextTransitionTime *string

	// The state of the calendar. An OPEN calendar indicates that actions are allowed
	// to proceed, and a CLOSED calendar indicates that actions are not allowed to
	// proceed.
	State types.CalendarState

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetCommandInvocationAPIClient interface {
	GetCommandInvocation(context.Context, *GetCommandInvocationInput, ...func(*Options)) (*GetCommandInvocationOutput, error)
}

type GetCommandInvocationInput struct {

	// (Required) The parent command ID of the invocation plugin.
	//
	// This member is required.
	CommandId *string

	// (Required) The ID of the managed instance targeted by the command. A managed
	// instance can be an EC2 instance or an instance in your hybrid environment that
	// is configured for Systems Manager.
	//
	// This member is required.
	InstanceId *string

	// (Optional) The name of the plugin for which you want detailed results. If the
	// document contains only one plugin, the name can be omitted and the details will
	// be returned. Plugin names are also referred to as step names in Systems Manager
	// documents.
	PluginName *string
}

type GetCommandInvocationOutput struct {

	// CloudWatch Logs information where Systems Manager sent the command output.
	CloudWatchOutputConfig *types.CloudWatchOutputConfig

	// The parent command ID of the invocation plugin.
	CommandId *string

	// The comment text for the command.
	Comment *string

	// The name of the document that was run. For example, AWS-RunShellScript.
	DocumentName *string

	// The SSM document version used in the request.
	DocumentVersion *string

	// Duration since ExecutionStartDateTime.
	ExecutionElapsedTime *string

	// The date and time the plugin was finished running. Date and time are written in
	// ISO 8601 format. For example, June 7, 2017 is represented as 2017-06-7. The
	// following sample AWS CLI command uses the InvokedAfter filter. aws ssm
	// list-commands --filters key=InvokedAfter,value=2017-06-07T00:00:00Z If the
	// plugin has not started to run, the string is empty.
	ExecutionEndDateTime *string

	// The date and time the plugin started running. Date and time are written in ISO
	// 8601 format. For example, June 7, 2017 is represented as 2017-06-7. The
	// following sample AWS CLI command uses the InvokedBefore filter. aws ssm
	// list-commands --filters key=InvokedBefore,value=2017-06-07T00:00:00Z If the
	// plugin has not started to run, the string is empty.
	ExecutionStartDateTime *string

	// The ID of the managed instance targeted by the command. A managed instance can
	// be an EC2 instance or an instance in your hybrid environment that is configured
	// for Systems Manager.
	InstanceId *string

	// The name of the plugin for which you want detailed results. For example,
	// aws:RunShellScript is a plugin.
	PluginName *string

	// The error level response code for the plugin script. If the response code is -1,
	// then the command has not started running on the instance, or it was not received
	// by the instance.
	ResponseCode int32

	// The first 8,000 characters written by the plugin to stderr. If the command has
	// not finished running, then this string is empty.
	StandardErrorContent *string

	// The URL for the complete text written by the plugin to stderr. If the command
	// has not finished running, then this string is empty.
	StandardErrorUrl *string

	// The first 24,000 characters written by the plugin to stdout. If the command has
	// not finished running, if ExecutionStatus is neither Succeeded nor Failed, then
	// this string is empty.
	StandardOutputContent *string

	// The URL for the complete text written by the plugin to stdout in Amazon S3. If
	// an S3 bucket was not specified, then this string is empty.
	StandardOutputUrl *string

	// The status of this invocation plugin. This status can be different than
	// StatusDetails.
	Status types.CommandInvocationStatus

	// A detailed status of the command execution for an invocation. StatusDetails
	// includes more information than Status because it includes states resulting from
	// error and concurrency control parameters. StatusDetails can show different
	// results than Status. For more information about these statuses, see
	// Understanding command statuses
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/monitor-commands.html)
	// in the AWS Systems Manager User Guide. StatusDetails can be one of the following
	// values:
	//
	// * Pending: The command has not been sent to the instance.
	//
	// * In
	// Progress: The command has been sent to the instance but has not reached a
	// terminal state.
	//
	// * Delayed: The system attempted to send the command to the
	// target, but the target was not available. The instance might not be available
	// because of network issues, because the instance was stopped, or for similar
	// reasons. The system will try to send the command again.
	//
	// * Success: The command
	// or plugin ran successfully. This is a terminal state.
	//
	// * Delivery Timed Out: The
	// command was not delivered to the instance before the delivery timeout expired.
	// Delivery timeouts do not count against the parent command's MaxErrors limit, but
	// they do contribute to whether the parent command status is Success or
	// Incomplete. This is a terminal state.
	//
	// * Execution Timed Out: The command
	// started to run on the instance, but the execution was not complete before the
	// timeout expired. Execution timeouts count against the MaxErrors limit of the
	// parent command. This is a terminal state.
	//
	// * Failed: The command wasn't run
	// successfully on the instance. For a plugin, this indicates that the result code
	// was not zero. For a command invocation, this indicates that the result code for
	// one or more plugins was not zero. Invocation failures count against the
	// MaxErrors limit of the parent command. This is a terminal state.
	//
	// * Canceled:
	// The command was terminated before it was completed. This is a terminal state.
	//
	// *
	// Undeliverable: The command can't be delivered to the instance. The instance
	// might not exist or might not be responding. Undeliverable invocations don't
	// count against the parent command's MaxErrors limit and don't contribute to
	// whether the parent command status is Success or Incomplete. This is a terminal
	// state.
	//
	// * Terminated: The parent command exceeded its MaxErrors limit and
	// subsequent command invocations were canceled by the system. This is a terminal
	// state.
	StatusDetails *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetConnectionStatusInput struct {

	// The ID of the instance.
	//
	// This member is required.
	Target *string
}

type GetConnectionStatusOutput struct {

	// The status of the connection to the instance. For example, 'Connected' or 'Not
	// Connected'.
	Status types.ConnectionStatus

	// The ID of the instance to check connection status.
	Target *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDefaultPatchBaselineInput struct {

	// Returns the default patch baseline for the specified operating system.
	OperatingSystem types.OperatingSystem
}

type GetDefaultPatchBaselineOutput struct {

	// The ID of the default patch baseline.
	BaselineId *string

	// The operating system for the returned patch baseline.
	OperatingSystem types.OperatingSystem

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDeployablePatchSnapshotForInstanceInput struct {

	// The ID of the instance for which the appropriate patch snapshot should be
	// retrieved.
	//
	// This member is required.
	InstanceId *string

	// The user-defined snapshot ID.
	//
	// This member is required.
	SnapshotId *string
}

type GetDeployablePatchSnapshotForInstanceOutput struct {

	// The ID of the instance.
	InstanceId *string

	// Returns the specific operating system (for example Windows Server 2012 or Amazon
	// Linux 2015.09) on the instance for the specified patch snapshot.
	Product *string

	// A pre-signed Amazon S3 URL that can be used to download the patch snapshot.
	SnapshotDownloadUrl *string

	// The user-defined snapshot ID.
	SnapshotId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDocumentInput struct {

	// The name of the Systems Manager document.
	//
	// This member is required.
	Name *string

	// Returns the document in the specified format. The document format can be either
	// JSON or YAML. JSON is the default format.
	DocumentFormat types.DocumentFormat

	// The document version for which you want information.
	DocumentVersion *string

	// An optional field specifying the version of the artifact associated with the
	// document. For example, "Release 12, Update 6". This value is unique across all
	// versions of a document and can't be changed.
	VersionName *string
}

type GetDocumentOutput struct {

	// A description of the document attachments, including names, locations, sizes,
	// and so on.
	AttachmentsContent []types.AttachmentContent

	// The contents of the Systems Manager document.
	Content *string

	// The document format, either JSON or YAML.
	DocumentFormat types.DocumentFormat

	// The document type.
	DocumentType types.DocumentType

	// The document version.
	DocumentVersion *string

	// The name of the Systems Manager document.
	Name *string

	// A list of SSM documents required by a document. For example, an
	// ApplicationConfiguration document requires an ApplicationConfigurationSchema
	// document.
	Requires []types.DocumentRequires

	// The current review status of a new custom Systems Manager document (SSM
	// document) created by a member of your organization, or of the latest version of
	// an existing SSM document. Only one version of an SSM document can be in the
	// APPROVED state at a time. When a new version is approved, the status of the
	// previous version changes to REJECTED. Only one version of an SSM document can be
	// in review, or PENDING, at a time.
	ReviewStatus types.ReviewStatus

	// The status of the Systems Manager document, such as Creating, Active, Updating,
	// Failed, and Deleting.
	Status types.DocumentStatus

	// A message returned by AWS Systems Manager that explains the Status value. For
	// example, a Failed status might be explained by the StatusInformation message,
	// "The specified S3 bucket does not exist. Verify that the URL of the S3 bucket is
	// correct."
	StatusInformation *string

	// The version of the artifact associated with the document. For example, "Release
	// 12, Update 6". This value is unique across all versions of a document, and
	// cannot be changed.
	VersionName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetInventoryAPIClient interface {
	GetInventory(context.Context, *GetInventoryInput, ...func(*Options)) (*GetInventoryOutput, error)
}

type GetInventoryInput struct {

	// Returns counts of inventory types based on one or more expressions. For example,
	// if you aggregate by using an expression that uses the
	// AWS:InstanceInformation.PlatformType type, you can see a count of how many
	// Windows and Linux instances exist in your inventoried fleet.
	Aggregators []types.InventoryAggregator

	// One or more filters. Use a filter to return a more specific list of results.
	Filters []types.InventoryFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// The list of inventory item types to return.
	ResultAttributes []types.ResultAttribute
}

type GetInventoryOutput struct {

	// Collection of inventory entities such as a collection of instance inventory.
	Entities []types.InventoryResultEntity

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetInventoryPaginator struct {
	// contains filtered or unexported fields
}

type GetInventoryPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetInventorySchemaAPIClient interface {
	GetInventorySchema(context.Context, *GetInventorySchemaInput, ...func(*Options)) (*GetInventorySchemaOutput, error)
}

type GetInventorySchemaInput struct {

	// Returns inventory schemas that support aggregation. For example, this call
	// returns the AWS:InstanceInformation type, because it supports aggregation based
	// on the PlatformName, PlatformType, and PlatformVersion attributes.
	Aggregator bool

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// Returns the sub-type schema for a specified inventory type.
	SubType bool

	// The type of inventory item to return.
	TypeName *string
}

type GetInventorySchemaOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// Inventory schemas returned by the request.
	Schemas []types.InventoryItemSchema

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetInventorySchemaPaginator struct {
	// contains filtered or unexported fields
}

type GetInventorySchemaPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetMaintenanceWindowExecutionInput struct {

	// The ID of the maintenance window execution that includes the task.
	//
	// This member is required.
	WindowExecutionId *string
}

type GetMaintenanceWindowExecutionOutput struct {

	// The time the maintenance window finished running.
	EndTime *time.Time

	// The time the maintenance window started running.
	StartTime *time.Time

	// The status of the maintenance window execution.
	Status types.MaintenanceWindowExecutionStatus

	// The details explaining the Status. Only available for certain status values.
	StatusDetails *string

	// The ID of the task executions from the maintenance window execution.
	TaskIds []string

	// The ID of the maintenance window execution.
	WindowExecutionId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMaintenanceWindowExecutionTaskInput struct {

	// The ID of the specific task execution in the maintenance window task that should
	// be retrieved.
	//
	// This member is required.
	TaskId *string

	// The ID of the maintenance window execution that includes the task.
	//
	// This member is required.
	WindowExecutionId *string
}

type GetMaintenanceWindowExecutionTaskInvocationInput struct {

	// The invocation ID to retrieve.
	//
	// This member is required.
	InvocationId *string

	// The ID of the specific task in the maintenance window task that should be
	// retrieved.
	//
	// This member is required.
	TaskId *string

	// The ID of the maintenance window execution for which the task is a part.
	//
	// This member is required.
	WindowExecutionId *string
}

type GetMaintenanceWindowExecutionTaskInvocationOutput struct {

	// The time that the task finished running on the target.
	EndTime *time.Time

	// The execution ID.
	ExecutionId *string

	// The invocation ID.
	InvocationId *string

	// User-provided value to be included in any CloudWatch events raised while running
	// tasks for these targets in this maintenance window.
	OwnerInformation *string

	// The parameters used at the time that the task ran.
	Parameters *string

	// The time that the task started running on the target.
	StartTime *time.Time

	// The task status for an invocation.
	Status types.MaintenanceWindowExecutionStatus

	// The details explaining the status. Details are only available for certain status
	// values.
	StatusDetails *string

	// The task execution ID.
	TaskExecutionId *string

	// Retrieves the task type for a maintenance window. Task types include the
	// following: LAMBDA, STEP_FUNCTIONS, AUTOMATION, RUN_COMMAND.
	TaskType types.MaintenanceWindowTaskType

	// The maintenance window execution ID.
	WindowExecutionId *string

	// The maintenance window target ID.
	WindowTargetId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMaintenanceWindowExecutionTaskOutput struct {

	// The time the task execution completed.
	EndTime *time.Time

	// The defined maximum number of task executions that could be run in parallel.
	MaxConcurrency *string

	// The defined maximum number of task execution errors allowed before scheduling of
	// the task execution would have been stopped.
	MaxErrors *string

	// The priority of the task.
	Priority int32

	// The role that was assumed when running the task.
	ServiceRole *string

	// The time the task execution started.
	StartTime *time.Time

	// The status of the task.
	Status types.MaintenanceWindowExecutionStatus

	// The details explaining the Status. Only available for certain status values.
	StatusDetails *string

	// The ARN of the task that ran.
	TaskArn *string

	// The ID of the specific task execution in the maintenance window task that was
	// retrieved.
	TaskExecutionId *string

	// The parameters passed to the task when it was run. TaskParameters has been
	// deprecated. To specify parameters to pass to a task when it runs, instead use
	// the Parameters option in the TaskInvocationParameters structure. For information
	// about how Systems Manager handles these options for the supported maintenance
	// window task types, see MaintenanceWindowTaskInvocationParameters. The map has
	// the following format: Key: string, between 1 and 255 characters Value: an array
	// of strings, each string is between 1 and 255 characters
	TaskParameters []map[string]types.MaintenanceWindowTaskParameterValueExpression

	// The type of task that was run.
	Type types.MaintenanceWindowTaskType

	// The ID of the maintenance window execution that includes the task.
	WindowExecutionId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMaintenanceWindowInput struct {

	// The ID of the maintenance window for which you want to retrieve information.
	//
	// This member is required.
	WindowId *string
}

type GetMaintenanceWindowOutput struct {

	// Whether targets must be registered with the maintenance window before tasks can
	// be defined for those targets.
	AllowUnassociatedTargets bool

	// The date the maintenance window was created.
	CreatedDate *time.Time

	// The number of hours before the end of the maintenance window that Systems
	// Manager stops scheduling new tasks for execution.
	Cutoff int32

	// The description of the maintenance window.
	Description *string

	// The duration of the maintenance window in hours.
	Duration int32

	// Indicates whether the maintenance window is enabled.
	Enabled bool

	// The date and time, in ISO-8601 Extended format, for when the maintenance window
	// is scheduled to become inactive. The maintenance window will not run after this
	// specified time.
	EndDate *string

	// The date the maintenance window was last modified.
	ModifiedDate *time.Time

	// The name of the maintenance window.
	Name *string

	// The next time the maintenance window will actually run, taking into account any
	// specified times for the maintenance window to become active or inactive.
	NextExecutionTime *string

	// The schedule of the maintenance window in the form of a cron or rate expression.
	Schedule *string

	// The number of days to wait to run a maintenance window after the scheduled CRON
	// expression date and time.
	ScheduleOffset int32

	// The time zone that the scheduled maintenance window executions are based on, in
	// Internet Assigned Numbers Authority (IANA) format. For example:
	// "America/Los_Angeles", "UTC", or "Asia/Seoul". For more information, see the
	// Time Zone Database (https://www.iana.org/time-zones) on the IANA website.
	ScheduleTimezone *string

	// The date and time, in ISO-8601 Extended format, for when the maintenance window
	// is scheduled to become active. The maintenance window will not run before this
	// specified time.
	StartDate *string

	// The ID of the created maintenance window.
	WindowId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetMaintenanceWindowTaskInput struct {

	// The maintenance window ID that includes the task to retrieve.
	//
	// This member is required.
	WindowId *string

	// The maintenance window task ID to retrieve.
	//
	// This member is required.
	WindowTaskId *string
}

type GetMaintenanceWindowTaskOutput struct {

	// The retrieved task description.
	Description *string

	// The location in Amazon S3 where the task results are logged. LoggingInfo has
	// been deprecated. To specify an S3 bucket to contain logs, instead use the
	// OutputS3BucketName and OutputS3KeyPrefix options in the TaskInvocationParameters
	// structure. For information about how Systems Manager handles these options for
	// the supported maintenance window task types, see
	// MaintenanceWindowTaskInvocationParameters.
	LoggingInfo *types.LoggingInfo

	// The maximum number of targets allowed to run this task in parallel. For
	// maintenance window tasks without a target specified, you cannot supply a value
	// for this option. Instead, the system inserts a placeholder value of 1, which may
	// be reported in the response to this command. This value does not affect the
	// running of your task and can be ignored.
	MaxConcurrency *string

	// The maximum number of errors allowed before the task stops being scheduled. For
	// maintenance window tasks without a target specified, you cannot supply a value
	// for this option. Instead, the system inserts a placeholder value of 1, which may
	// be reported in the response to this command. This value does not affect the
	// running of your task and can be ignored.
	MaxErrors *string

	// The retrieved task name.
	Name *string

	// The priority of the task when it runs. The lower the number, the higher the
	// priority. Tasks that have the same priority are scheduled in parallel.
	Priority int32

	// The ARN of the IAM service role to use to publish Amazon Simple Notification
	// Service (Amazon SNS) notifications for maintenance window Run Command tasks.
	ServiceRoleArn *string

	// The targets where the task should run.
	Targets []types.Target

	// The resource that the task used during execution. For RUN_COMMAND and AUTOMATION
	// task types, the TaskArn is the Systems Manager Document name/ARN. For LAMBDA
	// tasks, the value is the function name/ARN. For STEP_FUNCTIONS tasks, the value
	// is the state machine ARN.
	TaskArn *string

	// The parameters to pass to the task when it runs.
	TaskInvocationParameters *types.MaintenanceWindowTaskInvocationParameters

	// The parameters to pass to the task when it runs. TaskParameters has been
	// deprecated. To specify parameters to pass to a task when it runs, instead use
	// the Parameters option in the TaskInvocationParameters structure. For information
	// about how Systems Manager handles these options for the supported maintenance
	// window task types, see MaintenanceWindowTaskInvocationParameters.
	TaskParameters map[string]types.MaintenanceWindowTaskParameterValueExpression

	// The type of task to run.
	TaskType types.MaintenanceWindowTaskType

	// The retrieved maintenance window ID.
	WindowId *string

	// The retrieved maintenance window task ID.
	WindowTaskId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetOpsItemInput struct {

	// The ID of the OpsItem that you want to get.
	//
	// This member is required.
	OpsItemId *string
}

type GetOpsItemOutput struct {

	// The OpsItem.
	OpsItem *types.OpsItem

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetOpsMetadataInput struct {

	// The Amazon Resource Name (ARN) of an OpsMetadata Object to view.
	//
	// This member is required.
	OpsMetadataArn *string

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string
}

type GetOpsMetadataOutput struct {

	// OpsMetadata for an Application Manager application.
	Metadata map[string]types.MetadataValue

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// The resource ID of the Application Manager application.
	ResourceId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetOpsSummaryAPIClient interface {
	GetOpsSummary(context.Context, *GetOpsSummaryInput, ...func(*Options)) (*GetOpsSummaryOutput, error)
}

type GetOpsSummaryInput struct {

	// Optional aggregators that return counts of OpsItems based on one or more
	// expressions.
	Aggregators []types.OpsAggregator

	// Optional filters used to scope down the returned OpsItems.
	Filters []types.OpsFilter

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// A token to start the list. Use this token to get the next set of results.
	NextToken *string

	// The OpsItem data type to return.
	ResultAttributes []types.OpsResultAttribute

	// Specify the name of a resource data sync to get.
	SyncName *string
}

type GetOpsSummaryOutput struct {

	// The list of aggregated and filtered OpsItems.
	Entities []types.OpsEntity

	// The token for the next set of items to return. Use this token to get the next
	// set of results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetOpsSummaryPaginator struct {
	// contains filtered or unexported fields
}

type GetOpsSummaryPaginatorOptions struct {
	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type GetParameterHistoryAPIClient interface {
	GetParameterHistory(context.Context, *GetParameterHistoryInput, ...func(*Options)) (*GetParameterHistoryOutput, error)
}

type GetParameterHistoryInput struct {

	// The name of the parameter for which you want to review history.
	//
	// This member is required.
	Name *string

	// The maximum number of items to return for this call. The call also returns a
	// token that you can specify in a subsequent call to get the next set of results.
	MaxResults int32

	// The token for the next set of items to return. (You received this token from a
	// previous call.)
	NextToken *string

	// Return decrypted values for secure string parameters. This flag is ignored for
	// String and StringList parameter types.
	WithDecryption bool
}

type GetParameterHistoryOutput struct {

	// The token to use when requesting the next set of items. If there are no
	// additional items to return, the string is empty.
	NextToken *string

	// A list of parameters returned by the request.
	Parameters []types.ParameterHistory

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetParameterHistoryPaginator struct {
	// contains filtered or unexported fields
}