type AccountSharingInfo struct {
	// The AWS account ID where the current document is shared.
	AccountId *string
	// The version of the current document shared with the account.
	SharedDocumentVersion *string
}

type Activation struct {
	// A user defined description of the activation.
	Description *string
	// The maximum number of managed instances that can be registered using this
	// activation.
	RegistrationLimit *int32
	// The date the activation was created.
	CreatedDate *time.Time
	// The date when this activation can no longer be used to register managed
	// instances.
	ExpirationDate *time.Time
	// A name for the managed instance when it is created.
	DefaultInstanceName *string
	// Whether or not the activation is expired.
	Expired *bool
	// The ID created by Systems Manager when you submitted the activation.
	ActivationId *string
	// Tags assigned to the activation.
	Tags []*Tag
	// The number of managed instances already registered with this activation.
	RegistrationsCount *int32
	// The Amazon Identity and Access Management (IAM) role to assign to the managed
	// instance.
	IamRole *string
}

type AlreadyExistsException struct {
	Message *string
}

type AssociatedInstances struct {
	Message *string
}

type Association struct {
	// The instances targeted by the request to create an association.
	Targets []*Target
	// The ID of the instance.
	InstanceId *string
	// The association version.
	AssociationVersion *string
	// The ID created by the system when you create an association. An association is a
	// binding between a document and a set of targets with a schedule.
	AssociationId *string
	// The name of the Systems Manager document.
	Name *string
	// The version of the document used in the association.
	DocumentVersion *string
	// A cron expression that specifies a schedule when the association runs.
	ScheduleExpression *string
	// The association name.
	AssociationName *string
	// The date on which the association was last run.
	LastExecutionDate *time.Time
	// Information about the association.
	Overview *AssociationOverview
}

type AssociationAlreadyExists struct {
	Message *string
}

type AssociationComplianceSeverity string

const (
	AssociationComplianceSeverityCritical    AssociationComplianceSeverity = "CRITICAL"
	AssociationComplianceSeverityHigh        AssociationComplianceSeverity = "HIGH"
	AssociationComplianceSeverityMedium      AssociationComplianceSeverity = "MEDIUM"
	AssociationComplianceSeverityLow         AssociationComplianceSeverity = "LOW"
	AssociationComplianceSeverityUnspecified AssociationComplianceSeverity = "UNSPECIFIED"
)

type AssociationDescription struct {
	// The document version.
	DocumentVersion *string
	// An S3 bucket where you want to store the output details of the request.
	OutputLocation *InstanceAssociationOutputLocation
	// The ID of the instance.
	InstanceId *string
	// The date on which the association was last run.
	LastExecutionDate *time.Time
	// The association ID.
	AssociationId *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
	// 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
	// A cron expression that specifies a schedule when the association runs.
	ScheduleExpression *string
	// The name of the Systems Manager document.
	Name *string
	// The severity level that is assigned to the association.
	ComplianceSeverity AssociationComplianceSeverity
	// The association name.
	AssociationName *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 association status.
	Status *AssociationStatus
	// The association version.
	AssociationVersion *string
	// A description of the parameters for a document.
	Parameters map[string][]*string
	// The date when the association was last updated.
	LastUpdateAssociationDate *time.Time
	// 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.
	ApplyOnlyAtCronInterval *bool
	// 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 AssociationSyncCompliance
	// The instances targeted by the request.
	Targets []*Target
	// The last date on which the association was successfully run.
	LastSuccessfulExecutionDate *time.Time
	// Information about the association.
	Overview *AssociationOverview
	// The date when the association was made.
	Date *time.Time
}

type AssociationDoesNotExist struct {
	Message *string
}

type AssociationExecution struct {
	// An aggregate status of the resources in the execution based on the status type.
	ResourceCountByStatus *string
	// Detailed status information about the execution.
	DetailedStatus *string
	// The association version.
	AssociationVersion *string
	// The status of the association execution.
	Status *string
	// The time the execution started.
	CreatedTime *time.Time
	// The date of the last execution.
	LastExecutionDate *time.Time
	// The association ID.
	AssociationId *string
	// The execution ID for the association.
	ExecutionId *string
}

type AssociationExecutionDoesNotExist struct {
	Message *string
}

type AssociationExecutionFilter struct {
	// The filter type specified in the request.
	Type AssociationFilterOperatorType
	// The value specified for the key.
	Value *string
	// The key value used in the request.
	Key AssociationExecutionFilterKey
}

type AssociationExecutionFilterKey string

const (
	AssociationExecutionFilterKeyExecutionid AssociationExecutionFilterKey = "ExecutionId"
	AssociationExecutionFilterKeyStatus      AssociationExecutionFilterKey = "Status"
	AssociationExecutionFilterKeyCreatedtime AssociationExecutionFilterKey = "CreatedTime"
)

type AssociationExecutionTarget struct {
	// Detailed information about the execution status.
	DetailedStatus *string
	// The association ID.
	AssociationId *string
	// The association version.
	AssociationVersion *string
	// The resource ID, for example, the instance ID where the association ran.
	ResourceId *string
	// The association execution status.
	Status *string
	// The date of the last execution.
	LastExecutionDate *time.Time
	// The resource type, for example, instance.
	ResourceType *string
	// The execution ID.
	ExecutionId *string
	// The location where the association details are saved.
	OutputSource *OutputSource
}

type AssociationExecutionTargetsFilter struct {
	// The key value used in the request.
	Key AssociationExecutionTargetsFilterKey
	// The value specified for the key.
	Value *string
}

type AssociationExecutionTargetsFilterKey string

const (
	AssociationExecutionTargetsFilterKeyStatus       AssociationExecutionTargetsFilterKey = "Status"
	AssociationExecutionTargetsFilterKeyResourceid   AssociationExecutionTargetsFilterKey = "ResourceId"
	AssociationExecutionTargetsFilterKeyResourcetype AssociationExecutionTargetsFilterKey = "ResourceType"
)

type AssociationFilter struct {
	// The name of the filter.
	Key AssociationFilterKey
	// The filter value.
	Value *string
}

type AssociationFilterKey string

const (
	AssociationFilterKeyInstanceid         AssociationFilterKey = "InstanceId"
	AssociationFilterKeyName               AssociationFilterKey = "Name"
	AssociationFilterKeyAssociationid      AssociationFilterKey = "AssociationId"
	AssociationFilterKeyStatus             AssociationFilterKey = "AssociationStatusName"
	AssociationFilterKeyLastexecutedbefore AssociationFilterKey = "LastExecutedBefore"
	AssociationFilterKeyLastexecutedafter  AssociationFilterKey = "LastExecutedAfter"
	AssociationFilterKeyAssociationname    AssociationFilterKey = "AssociationName"
	AssociationFilterKeyResourcegroupname  AssociationFilterKey = "ResourceGroupName"
)

type AssociationFilterOperatorType string

const (
	AssociationFilterOperatorTypeEqual       AssociationFilterOperatorType = "EQUAL"
	AssociationFilterOperatorTypeLessthan    AssociationFilterOperatorType = "LESS_THAN"
	AssociationFilterOperatorTypeGreaterthan AssociationFilterOperatorType = "GREATER_THAN"
)

type AssociationLimitExceeded struct {
	Message *string
}

type AssociationOverview struct {
	// Returns the number of targets for the association status. For example, if you
	// created an association with two instances, and one of them was successful, this
	// would return the count of instances by status.
	AssociationStatusAggregatedCount map[string]*int32
	// The status of the association. Status can be: Pending, Success, or Failed.
	Status *string
	// A detailed status of the association.
	DetailedStatus *string
}

type AssociationStatus struct {
	// The status.
	Name AssociationStatusName
	// The date when the status changed.
	Date *time.Time
	// A user-defined string.
	AdditionalInfo *string
	// The reason for the status.
	Message *string
}

type AssociationStatusName string

const (
	AssociationStatusNamePending AssociationStatusName = "Pending"
	AssociationStatusNameSuccess AssociationStatusName = "Success"
	AssociationStatusNameFailed  AssociationStatusName = "Failed"
)

type AssociationSyncCompliance string

const (
	AssociationSyncComplianceAuto   AssociationSyncCompliance = "AUTO"
	AssociationSyncComplianceManual AssociationSyncCompliance = "MANUAL"
)

type AssociationVersionInfo struct {
	// The name specified when the association was created.
	Name *string
	// The association version.
	AssociationVersion *string
	// The date the association version was created.
	CreatedDate *time.Time
	// The severity level that is assigned to the association.
	ComplianceSeverity AssociationComplianceSeverity
	// 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
	// The cron or rate schedule specified for the association when the association
	// version was created.
	ScheduleExpression *string
	// The name specified for the association version when the association version was
	// created.
	AssociationName *string
	// Parameters specified when the association version was created.
	Parameters map[string][]*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.
	ApplyOnlyAtCronInterval *bool
	// 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 version of a Systems Manager document used when the association version was
	// created.
	DocumentVersion *string
	// The location in Amazon S3 specified for the association when the association
	// version was created.
	OutputLocation *InstanceAssociationOutputLocation
	// The targets specified for the association when the association version was
	// created.
	Targets []*Target
	// 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 AssociationSyncCompliance
	// The ID created by the system when the association was created.
	AssociationId *string
}

type AssociationVersionLimitExceeded struct {
	Message *string
}

type AttachmentContent struct {
	// The name of an attachment.
	Name *string
	// The cryptographic hash value of the document content.
	Hash *string
	// The URL location of the attachment content.
	Url *string
	// The hash algorithm used to calculate the hash value.
	HashType AttachmentHashType
	// The size of an attachment in bytes.
	Size *int64
}

type AttachmentHashType string

const (
	AttachmentHashTypeSha256 AttachmentHashType = "Sha256"
)

type AttachmentInformation struct {
	// The name of the attachment.
	Name *string
}

type AttachmentsSource struct {
	// The name of the document attachment file.
	Name *string
	// The key of a key-value pair that identifies the location of an attachment to a
	// document.
	Key AttachmentsSourceKey
	// The value of a key-value pair that identifies the location of an attachment to a
	// document. The format for Value depends on the type of key you specify.
	//
	//     *
	// For the key SourceUrl, the value is an S3 bucket location. For example:
	// "Values": [ "s3://my-bucket/my-folder" ]
	//
	//     * For the key S3FileUrl, the value
	// is a file in an S3 bucket. For example: "Values": [
	// "s3://my-bucket/my-folder/my-file.py" ]
	//
	//     * For the key AttachmentReference,
	// the value is constructed from the name of another SSM document in your account,
	// a version number of that document, and a file attached to that document version
	// that you want to reuse. For example: "Values": [
	// "MyOtherDocument/3/my-other-file.py" ] However, if the SSM document is shared
	// with you from another account, the full SSM document ARN must be specified
	// instead of the document name only. For example: "Values": [
	// "arn:aws:ssm:us-east-2:111122223333:document/OtherAccountDocument/3/their-file.py"
	// ]
	Values []*string
}

type AttachmentsSourceKey string

const (
	AttachmentsSourceKeySourceurl           AttachmentsSourceKey = "SourceUrl"
	AttachmentsSourceKeyS3fileurl           AttachmentsSourceKey = "S3FileUrl"
	AttachmentsSourceKeyAttachmentreference AttachmentsSourceKey = "AttachmentReference"
)

type AutomationDefinitionNotFoundException struct {
	Message *string
}

type AutomationDefinitionVersionNotFoundException struct {
	Message *string
}

type AutomationExecution struct {
	// The MaxErrors value specified by the user when the execution started.
	MaxErrors *string
	// A list of resolved targets in the rate control execution.
	ResolvedTargets *ResolvedTargets
	// The time the execution started.
	ExecutionStartTime *time.Time
	// The action of the step that is currently running.
	CurrentAction *string
	// The combination of AWS Regions and/or AWS accounts where you want to run the
	// Automation.
	TargetLocations []*TargetLocation
	// The version of the document to use during execution.
	DocumentVersion *string
	// A message describing why an execution has failed, if the status is set to
	// Failed.
	FailureMessage *string
	// The specified targets.
	Targets []*Target
	// The parameter name.
	TargetParameterName *string
	// The specified key-value mapping of document parameters to target resources.
	TargetMaps []map[string][]*string
	// The key-value map of execution parameters, which were supplied when calling
	// StartAutomationExecution.
	Parameters map[string][]*string
	// The list of execution outputs as defined in the automation document.
	Outputs map[string][]*string
	// The name of the step that is currently running.
	CurrentStepName *string
	// The MaxConcurrency value specified by the user when the execution started.
	MaxConcurrency *string
	// The automation execution mode.
	Mode ExecutionMode
	// The AutomationExecutionId of the parent automation.
	ParentAutomationExecutionId *string
	// The name of the Automation document used during the execution.
	DocumentName *string
	// The Amazon Resource Name (ARN) of the user who ran the automation.
	ExecutedBy *string
	// A boolean value that indicates if the response contains the full list of the
	// Automation step executions. If true, use the DescribeAutomationStepExecutions
	// API action to get the full list of step executions.
	StepExecutionsTruncated *bool
	// The execution status of the Automation.
	AutomationExecutionStatus AutomationExecutionStatus
	// The execution ID.
	AutomationExecutionId *string
	// The target of the execution.
	Target *string
	// A list of details about the current state of all steps that comprise an
	// execution. An Automation document contains a list of steps that are run in
	// order.
	StepExecutions []*StepExecution
	// The time the execution finished.
	ExecutionEndTime *time.Time
	// An aggregate of step execution statuses displayed in the AWS Console for a
	// multi-Region and multi-account Automation execution.
	ProgressCounters *ProgressCounters
}

type AutomationExecutionFilter struct {
	// One or more keys to limit the results. Valid filter keys include the following:
	// DocumentNamePrefix, ExecutionStatus, ExecutionId, ParentExecutionId,
	// CurrentAction, StartTimeBefore, StartTimeAfter.
	Key AutomationExecutionFilterKey
	// The values used to limit the execution information associated with the filter's
	// key.
	Values []*string
}

type AutomationExecutionFilterKey string

const (
	AutomationExecutionFilterKeyDocument_name_prefix AutomationExecutionFilterKey = "DocumentNamePrefix"
	AutomationExecutionFilterKeyExecution_status     AutomationExecutionFilterKey = "ExecutionStatus"
	AutomationExecutionFilterKeyExecution_id         AutomationExecutionFilterKey = "ExecutionId"
	AutomationExecutionFilterKeyParent_execution_id  AutomationExecutionFilterKey = "ParentExecutionId"
	AutomationExecutionFilterKeyCurrent_action       AutomationExecutionFilterKey = "CurrentAction"
	AutomationExecutionFilterKeyStart_time_before    AutomationExecutionFilterKey = "StartTimeBefore"
	AutomationExecutionFilterKeyStart_time_after     AutomationExecutionFilterKey = "StartTimeAfter"
	AutomationExecutionFilterKeyAutomation_type      AutomationExecutionFilterKey = "AutomationType"
	AutomationExecutionFilterKeyTag_key              AutomationExecutionFilterKey = "TagKey"
)

type AutomationExecutionLimitExceededException struct {
	Message *string
}

type AutomationExecutionMetadata struct {
	// The ExecutionId of the parent Automation.
	ParentAutomationExecutionId *string
	// The execution ID.
	AutomationExecutionId *string
	// A list of targets that resolved during the execution.
	ResolvedTargets *ResolvedTargets
	// Use this filter with DescribeAutomationExecutions (). Specify either Local or
	// CrossAccount. CrossAccount is an Automation that runs in multiple AWS Regions
	// and accounts. For more information, see Running Automation workflows in multiple
	// AWS Regions and accounts
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation-multiple-accounts-and-regions.html)
	// in the AWS Systems Manager User Guide.
	AutomationType AutomationType
	// The IAM role ARN of the user who ran the Automation.
	ExecutedBy *string
	// The name of the step that is currently running.
	CurrentStepName *string
	// The name of the Automation document used during execution.
	DocumentName *string
	// The MaxConcurrency value specified by the user when starting the Automation.
	MaxConcurrency *string
	// The list of execution outputs as defined in the Automation document.
	TargetParameterName *string
	// An S3 bucket where execution information is stored.
	LogFile *string
	// The time the execution finished. This is not populated if the execution is still
	// in progress.
	ExecutionEndTime *time.Time
	// The list of execution outputs as defined in the Automation document.
	Target *string
	// The status of the execution.
	AutomationExecutionStatus AutomationExecutionStatus
	// The list of execution outputs as defined in the Automation document.
	Outputs map[string][]*string
	// The action of the step that is currently running.
	CurrentAction *string
	// The MaxErrors value specified by the user when starting the Automation.
	MaxErrors *string
	// The Automation execution mode.
	Mode ExecutionMode
	// The specified key-value mapping of document parameters to target resources.
	TargetMaps []map[string][]*string
	// The list of execution outputs as defined in the Automation document.
	FailureMessage *string
	// The document version used during the execution.
	DocumentVersion *string
	// The time the execution started.
	ExecutionStartTime *time.Time
	// The targets defined by the user when starting the Automation.
	Targets []*Target
}

type AutomationExecutionNotFoundException struct {
	Message *string
}

type AutomationExecutionStatus string

const (
	AutomationExecutionStatusPending    AutomationExecutionStatus = "Pending"
	AutomationExecutionStatusInprogress AutomationExecutionStatus = "InProgress"
	AutomationExecutionStatusWaiting    AutomationExecutionStatus = "Waiting"
	AutomationExecutionStatusSuccess    AutomationExecutionStatus = "Success"
	AutomationExecutionStatusTimedout   AutomationExecutionStatus = "TimedOut"
	AutomationExecutionStatusCancelling AutomationExecutionStatus = "Cancelling"
	AutomationExecutionStatusCancelled  AutomationExecutionStatus = "Cancelled"
	AutomationExecutionStatusFailed     AutomationExecutionStatus = "Failed"
)

type AutomationStepNotFoundException struct {
	Message *string
}

type AutomationType string

const (
	AutomationTypeCrossaccount AutomationType = "CrossAccount"
	AutomationTypeLocal        AutomationType = "Local"
)

type CalendarState string

const (
	CalendarStateOpen   CalendarState = "OPEN"
	CalendarStateClosed CalendarState = "CLOSED"
)

type CloudWatchOutputConfig struct {
	// The name of the CloudWatch log group where you want to send command output. If
	// you don't specify a group name, Systems Manager automatically creates a log
	// group for you. The log group uses the following naming format:
	// aws/ssm/SystemsManagerDocumentName.
	CloudWatchLogGroupName *string
	// Enables Systems Manager to send command output to CloudWatch Logs.
	CloudWatchOutputEnabled *bool
}

type Command struct {
	// A unique identifier for this command.
	CommandId *string
	// The S3 directory path inside the bucket where the responses to the command
	// executions should be stored. This was requested when issuing the command.
	OutputS3KeyPrefix *string
	// The TimeoutSeconds value specified for a command.
	TimeoutSeconds *int32
	// The name of the document requested for execution.
	DocumentName *string
	// The S3 bucket where the responses to the command executions should be stored.
	// This was requested when issuing the command.
	OutputS3BucketName *string
	// CloudWatch Logs information where you want Systems Manager to send the command
	// output.
	CloudWatchOutputConfig *CloudWatchOutputConfig
	// The IAM service role that Run Command uses to act on your behalf when sending
	// notifications about command status changes.
	ServiceRole *string
	// If this time is reached and the command has not already started running, it will
	// not run. Calculated based on the ExpiresAfter user input provided as part of the
	// SendCommand API.
	ExpiresAfter *time.Time
	// The date and time the command was requested.
	RequestedDateTime *time.Time
	// The instance IDs against which this command was requested.
	InstanceIds []*string
	// The SSM document version.
	DocumentVersion *string
	// The status of the command.
	Status CommandStatus
	// An array of search criteria that targets instances using a Key,Value combination
	// that you specify. Targets is required if you don't provide one or more instance
	// IDs in the call.
	Targets []*Target
	// Configurations for sending notifications about command status changes.
	NotificationConfig *NotificationConfig
	// The number of targets for which the status is Failed or Execution Timed Out.
	ErrorCount *int32
	// User-specified information about the command, such as a brief description of
	// what the command should do.
	Comment *string
	// The number of targets for which the status is Delivery Timed Out.
	DeliveryTimedOutCount *int32
	// The maximum number of errors allowed before the system stops sending the command
	// to additional targets. You can specify a number of errors, such as 10, or a
	// percentage or errors, such as 10%. The default value is 0. For more information
	// about how to use MaxErrors, see Running commands using Systems Manager Run
	// Command
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/run-command.html)
	// in the AWS Systems Manager User Guide.
	MaxErrors *string
	// The parameter values to be inserted in the document when running the command.
	Parameters map[string][]*string
	// The number of targets for the command.
	TargetCount *int32
	// The number of targets for which the command invocation reached a terminal state.
	// Terminal states include the following: Success, Failed, Execution Timed Out,
	// Delivery Timed Out, Canceled, Terminated, or Undeliverable.
	CompletedCount *int32
	// A detailed status of the command execution. 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 any instances.
	//
	//     *
	// In Progress: The command has been sent to at least one instance but has not
	// reached a final state on all instances.
	//
	//     * Success: The command successfully
	// ran on all invocations. This is a terminal state.
	//
	//     * Delivery Timed Out: The
	// value of MaxErrors or more command invocations shows a status of Delivery Timed
	// Out. This is a terminal state.
	//
	//     * Execution Timed Out: The value of
	// MaxErrors or more command invocations shows a status of Execution Timed Out.
	// This is a terminal state.
	//
	//     * Failed: The value of MaxErrors or more command
	// invocations shows a status of Failed. This is a terminal state.
	//
	//     *
	// Incomplete: The command was attempted on all instances and one or more
	// invocations does not have a value of Success but not enough invocations failed
	// for the status to be Failed. This is a terminal state.
	//
	//     * Canceled: The
	// command was terminated before it was completed. This is a terminal state.
	//
	//     *
	// Rate Exceeded: The number of instances targeted by the command exceeded the
	// account limit for pending invocations. The system has canceled the command
	// before running it on any instance. This is a terminal state.
	StatusDetails *string
	// (Deprecated) You can no longer specify this parameter. The system ignores it.
	// Instead, Systems Manager automatically determines the Region of the S3 bucket.
	OutputS3Region *string
	// The maximum number of instances that are allowed to run the command at the same
	// time. You can specify a number of instances, such as 10, or a percentage of
	// instances, such as 10%. The default value is 50. For more information about how
	// to use MaxConcurrency, see Running commands using Systems Manager Run Command
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/run-command.html)
	// in the AWS Systems Manager User Guide.
	MaxConcurrency *string
}

type CommandFilter struct {
	// The name of the filter.
	Key CommandFilterKey
	// The filter value. Valid values for each filter key are as follows:
	//
	//     *
	// InvokedAfter: Specify a timestamp to limit your results. For example, specify
	// 2018-07-07T00:00:00Z to see a list of command executions occurring July 7, 2018,
	// and later.
	//
	//     * InvokedBefore: Specify a timestamp to limit your results. For
	// example, specify 2018-07-07T00:00:00Z to see a list of command executions from
	// before July 7, 2018.
	//
	//     * Status: Specify a valid command status to see a list
	// of all command executions with that status. Status values you can specify
	// include:
	//
	//         * Pending
	//
	//         * InProgress
	//
	//         * Success
	//
	//         *
	// Cancelled
	//
	//         * Failed
	//
	//         * TimedOut
	//
	//         * Cancelling
	//
	//     *
	// DocumentName: Specify name of the SSM document for which you want to see command
	// execution results. For example, specify AWS-RunPatchBaseline to see command
	// executions that used this SSM document to perform security patching operations
	// on instances.
	//
	//     * ExecutionStage: Specify one of the following values:
	//
	//
	// * Executing: Returns a list of command executions that are currently still
	// running.
	//
	//         * Complete: Returns a list of command executions that have
	// already completed.
	Value *string
}

type CommandFilterKey string

const (
	CommandFilterKeyInvoked_after   CommandFilterKey = "InvokedAfter"
	CommandFilterKeyInvoked_before  CommandFilterKey = "InvokedBefore"
	CommandFilterKeyStatus          CommandFilterKey = "Status"
	CommandFilterKeyExecution_stage CommandFilterKey = "ExecutionStage"
	CommandFilterKeyDocument_name   CommandFilterKey = "DocumentName"
)

type CommandInvocation struct {
	// The command against which this invocation was requested.
	CommandId *string
	// The name of the invocation target. For EC2 instances this is the value for the
	// aws:Name tag. For on-premises instances, this is the name of the instance.
	InstanceName *string
	// The URL to the plugin's StdErr file in Amazon S3, if the S3 bucket was defined
	// for the parent command. For an invocation, StandardErrorUrl is populated if
	// there is just one plugin defined for the command, and the S3 bucket was defined
	// for the command.
	StandardErrorUrl *string
	// The document name that was requested for execution.
	DocumentName *string
	// The time and date the request was sent to this instance.
	RequestedDateTime *time.Time
	// The IAM service role that Run Command uses to act on your behalf when sending
	// notifications about command status changes on a per instance basis.
	ServiceRole    *string
	CommandPlugins []*CommandPlugin
	// Whether or not the invocation succeeded, failed, or is pending.
	Status CommandInvocationStatus
	// CloudWatch Logs information where you want Systems Manager to send the command
	// output.
	CloudWatchOutputConfig *CloudWatchOutputConfig
	// The instance ID in which this invocation was requested.
	InstanceId *string
	// Configurations for sending notifications about command status changes on a per
	// instance basis.
	NotificationConfig *NotificationConfig
	// Gets the trace output sent by the agent.
	TraceOutput *string
	// The SSM document version.
	DocumentVersion *string
	// User-specified information about the command, such as a brief description of
	// what the command should do.
	Comment *string
	// The URL to the plugin's StdOut file in Amazon S3, if the S3 bucket was defined
	// for the parent command. For an invocation, StandardOutputUrl is populated if
	// there is just one plugin defined for the command, and the S3 bucket was defined
	// for the command.
	StandardOutputUrl *string
	// A detailed status of the command execution for each invocation (each instance
	// targeted by the command). 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.
	//
	//     * Success: The execution of the command or plugin was
	// successfully completed. 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: Command
	// execution started on the instance, but the execution was not complete before the
	// execution timeout expired. Execution timeouts count against the MaxErrors limit
	// of the parent command. This is a terminal state.
	//
	//     * Failed: The command was
	// not successful 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
}

type CommandInvocationStatus string

const (
	CommandInvocationStatusPending     CommandInvocationStatus = "Pending"
	CommandInvocationStatusIn_progress CommandInvocationStatus = "InProgress"
	CommandInvocationStatusDelayed     CommandInvocationStatus = "Delayed"
	CommandInvocationStatusSuccess     CommandInvocationStatus = "Success"
	CommandInvocationStatusCancelled   CommandInvocationStatus = "Cancelled"
	CommandInvocationStatusTimed_out   CommandInvocationStatus = "TimedOut"
	CommandInvocationStatusFailed      CommandInvocationStatus = "Failed"
	CommandInvocationStatusCancelling  CommandInvocationStatus = "Cancelling"
)

type CommandPlugin struct {
	// A detailed status of the plugin execution. 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.
	//
	//     * Success: The execution of the command or plugin was
	// successfully completed. 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: Command
	// execution started on the instance, but the execution was not complete before the
	// execution timeout expired. Execution timeouts count against the MaxErrors limit
	// of the parent command. This is a terminal state.
	//
	//     * Failed: The command was
	// not successful 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 it might not be responding. Undeliverable
	// invocations don't count against the parent command's MaxErrors limit, and they
	// 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
	// The status of this plugin. You can run a document with multiple plugins.
	Status CommandPluginStatus
	// The time the plugin stopped running. Could stop prematurely if, for example, a
	// cancel command was sent.
	ResponseFinishDateTime *time.Time
	// Output of the plugin execution.
	Output *string
	// The time the plugin started running.
	ResponseStartDateTime *time.Time
	// A numeric response code generated after running the plugin.
	ResponseCode *int32
	// (Deprecated) You can no longer specify this parameter. The system ignores it.
	// Instead, Systems Manager automatically determines the S3 bucket region.
	OutputS3Region *string
	// The URL for the complete text written by the plugin to stdout in Amazon S3. If
	// the S3 bucket for the command was not specified, then this string is empty.
	StandardOutputUrl *string
	// The S3 directory path inside the bucket where the responses to the command
	// executions should be stored. This was requested when issuing the command. For
	// example, in the following response:
	// test_folder/ab19cb99-a030-46dd-9dfc-8eSAMPLEPre-Fix/i-1234567876543/awsrunShellScript
	// test_folder is the name of the S3 bucket;
	// ab19cb99-a030-46dd-9dfc-8eSAMPLEPre-Fix is the name of the S3 prefix;
	// i-1234567876543 is the instance ID; awsrunShellScript is the name of the plugin.
	OutputS3KeyPrefix *string
	// The name of the plugin. Must be one of the following: aws:updateAgent,
	// aws:domainjoin, aws:applications, aws:runPowerShellScript, aws:psmodule,
	// aws:cloudWatch, aws:runShellScript, or aws:updateSSMAgent.
	Name *string
	// The S3 bucket where the responses to the command executions should be stored.
	// This was requested when issuing the command. For example, in the following
	// response:
	// test_folder/ab19cb99-a030-46dd-9dfc-8eSAMPLEPre-Fix/i-1234567876543/awsrunShellScript
	// test_folder is the name of the S3 bucket;
	// ab19cb99-a030-46dd-9dfc-8eSAMPLEPre-Fix is the name of the S3 prefix;
	// i-1234567876543 is the instance ID; awsrunShellScript is the name of the plugin.
	OutputS3BucketName *string
	// The URL for the complete text written by the plugin to stderr. If execution is
	// not yet complete, then this string is empty.
	StandardErrorUrl *string
}

type CommandPluginStatus string

const (
	CommandPluginStatusPending     CommandPluginStatus = "Pending"
	CommandPluginStatusIn_progress CommandPluginStatus = "InProgress"
	CommandPluginStatusSuccess     CommandPluginStatus = "Success"
	CommandPluginStatusTimed_out   CommandPluginStatus = "TimedOut"
	CommandPluginStatusCancelled   CommandPluginStatus = "Cancelled"
	CommandPluginStatusFailed      CommandPluginStatus = "Failed"
)

type CommandStatus string

const (
	CommandStatusPending     CommandStatus = "Pending"
	CommandStatusIn_progress CommandStatus = "InProgress"
	CommandStatusSuccess     CommandStatus = "Success"
	CommandStatusCancelled   CommandStatus = "Cancelled"
	CommandStatusFailed      CommandStatus = "Failed"
	CommandStatusTimed_out   CommandStatus = "TimedOut"
	CommandStatusCancelling  CommandStatus = "Cancelling"
)

type ComplianceExecutionSummary struct {
	// An ID created by the system when PutComplianceItems was called. For example,
	// CommandID is a valid execution ID. You can use this ID in subsequent calls.
	ExecutionId *string
	// The type of execution. For example, Command is a valid execution type.
	ExecutionType *string
	// The time the execution ran as a datetime object that is saved in the following
	// format: yyyy-MM-dd'T'HH:mm:ss'Z'.
	ExecutionTime *time.Time
}

type ComplianceItem struct {
	// An ID for the resource. For a managed instance, this is the instance ID.
	ResourceId *string
	// A summary for the compliance item. The summary includes an execution ID, the
	// execution type (for example, command), and the execution time.
	ExecutionSummary *ComplianceExecutionSummary
	// An ID for the compliance item. For example, if the compliance item is a Windows
	// patch, the ID could be the number of the KB article; for example: KB4010320.
	Id *string
	// A "Key": "Value" tag combination for the compliance item.
	Details map[string]*string
	// A title for the compliance item. For example, if the compliance item is a
	// Windows patch, the title could be the title of the KB article for the patch; for
	// example: Security Update for Active Directory Federation Services.
	Title *string
	// The status of the compliance item. An item is either COMPLIANT or NON_COMPLIANT.
	Status ComplianceStatus
	// The compliance type. For example, Association (for a State Manager association),
	// Patch, or Custom:string are all valid compliance types.
	ComplianceType *string
	// The severity of the compliance status. Severity can be one of the following:
	// Critical, High, Medium, Low, Informational, Unspecified.
	Severity ComplianceSeverity
	// The type of resource. ManagedInstance is currently the only supported resource
	// type.
	ResourceType *string
}

type ComplianceItemEntry struct {
	// A "Key": "Value" tag combination for the compliance item.
	Details map[string]*string
	// The status of the compliance item. An item is either COMPLIANT or NON_COMPLIANT.
	Status ComplianceStatus
	// The severity of the compliance status. Severity can be one of the following:
	// Critical, High, Medium, Low, Informational, Unspecified.
	Severity ComplianceSeverity
	// The title of the compliance item. For example, if the compliance item is a
	// Windows patch, the title could be the title of the KB article for the patch; for
	// example: Security Update for Active Directory Federation Services.
	Title *string
	// The compliance item ID. For example, if the compliance item is a Windows patch,
	// the ID could be the number of the KB article.
	Id *string
}

type ComplianceQueryOperatorType string

const (
	ComplianceQueryOperatorTypeEqual       ComplianceQueryOperatorType = "EQUAL"
	ComplianceQueryOperatorTypeNotequal    ComplianceQueryOperatorType = "NOT_EQUAL"
	ComplianceQueryOperatorTypeBeginwith   ComplianceQueryOperatorType = "BEGIN_WITH"
	ComplianceQueryOperatorTypeLessthan    ComplianceQueryOperatorType = "LESS_THAN"
	ComplianceQueryOperatorTypeGreaterthan ComplianceQueryOperatorType = "GREATER_THAN"
)

type ComplianceSeverity string

const (
	ComplianceSeverityCritical      ComplianceSeverity = "CRITICAL"
	ComplianceSeverityHigh          ComplianceSeverity = "HIGH"
	ComplianceSeverityMedium        ComplianceSeverity = "MEDIUM"
	ComplianceSeverityLow           ComplianceSeverity = "LOW"
	ComplianceSeverityInformational ComplianceSeverity = "INFORMATIONAL"
	ComplianceSeverityUnspecified   ComplianceSeverity = "UNSPECIFIED"
)

type ComplianceStatus string

const (
	ComplianceStatusCompliant    ComplianceStatus = "COMPLIANT"
	ComplianceStatusNoncompliant ComplianceStatus = "NON_COMPLIANT"
)

type ComplianceStringFilter struct {
	// The type of comparison that should be performed for the value: Equal, NotEqual,
	// BeginWith, LessThan, or GreaterThan.
	Type ComplianceQueryOperatorType
	// The name of the filter.
	Key *string
	// The value for which to search.
	Values []*string
}

type ComplianceSummaryItem struct {
	// The type of compliance item. For example, the compliance type can be
	// Association, Patch, or Custom:string.
	ComplianceType *string
	// A list of NON_COMPLIANT items for the specified compliance type.
	NonCompliantSummary *NonCompliantSummary
	// A list of COMPLIANT items for the specified compliance type.
	CompliantSummary *CompliantSummary
}

type ComplianceTypeCountLimitExceededException struct {
	Message *string
}

type ComplianceUploadType string

const (
	ComplianceUploadTypeComplete ComplianceUploadType = "COMPLETE"
	ComplianceUploadTypePartial  ComplianceUploadType = "PARTIAL"
)

type CompliantSummary struct {
	// A summary of the compliance severity by compliance type.
	SeveritySummary *SeveritySummary
	// The total number of resources that are compliant.
	CompliantCount *int32
}

type ConnectionStatus string

const (
	ConnectionStatusConnected     ConnectionStatus = "Connected"
	ConnectionStatusNot_connected ConnectionStatus = "NotConnected"
)

type CreateAssociationBatchRequestEntry struct {
	// The instances targeted by the request.
	Targets []*Target
	// The ID of the instance.
	InstanceId *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 document version.
	DocumentVersion *string
	// 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:aws: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.
	Name *string
	// The severity level to assign to the association.
	ComplianceSeverity AssociationComplianceSeverity
	// Specify a descriptive name for the association.
	AssociationName *string
	// A cron expression that specifies a schedule when the association runs.
	ScheduleExpression *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
	// 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 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 AssociationSyncCompliance
	// A description of the parameters for a document.
	Parameters map[string][]*string
	// An S3 bucket where you want to store the results of this request.
	OutputLocation *InstanceAssociationOutputLocation
	// 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.
	ApplyOnlyAtCronInterval *bool
}

type CustomSchemaCountLimitExceededException struct {
	Message *string
}

type DescribeActivationsFilter struct {
	// The name of the filter.
	FilterKey DescribeActivationsFilterKeys
	// The filter values.
	FilterValues []*string
}

type DescribeActivationsFilterKeys string

const (
	DescribeActivationsFilterKeysActivation_ids        DescribeActivationsFilterKeys = "ActivationIds"
	DescribeActivationsFilterKeysDefault_instance_name DescribeActivationsFilterKeys = "DefaultInstanceName"
	DescribeActivationsFilterKeysIam_role              DescribeActivationsFilterKeys = "IamRole"
)

type DocumentAlreadyExists struct {
	Message *string
}

type DocumentDefaultVersionDescription struct {
	// The name of the document.
	Name *string
	// The default version of the artifact associated with the document.
	DefaultVersionName *string
	// The default version of the document.
	DefaultVersion *string
}

type DocumentDescription struct {
	// The schema version.
	SchemaVersion *string
	// The AWS user account that created the document.
	Owner *string
	// Details about the document attachments, including names, locations, sizes, and
	// so on.
	AttachmentsInformation []*AttachmentInformation
	// The date when the document was created.
	CreatedDate *time.Time
	// The default version.
	DefaultVersion *string
	// A list of SSM documents required by a document. For example, an
	// ApplicationConfiguration document requires an ApplicationConfigurationSchema
	// document.
	Requires []*DocumentRequires
	// The list of OS platforms compatible with this Systems Manager document.
	PlatformTypes []PlatformType
	// A description of the document.
	Description *string
	// The status of the Systems Manager document.
	Status DocumentStatus
	// The version of the artifact associated with the document.
	VersionName *string
	// The target type which defines the kinds of resources the document can run on.
	// For example, /AWS::EC2::Instance. 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
	// The document version.
	DocumentVersion *string
	// The document format, either JSON or YAML.
	DocumentFormat DocumentFormat
	// The tags, or metadata, that have been applied to the document.
	Tags []*Tag
	// The hash type of the document. Valid values include Sha256 or Sha1. Sha1 hashes
	// have been deprecated.
	HashType DocumentHashType
	// The Sha256 or Sha1 hash created by the system when the document was created.
	// Sha1 hashes have been deprecated.
	Hash *string
	// 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 SHA1 hash of the document, which you can use for verification.
	Sha1 *string
	// The latest version of the document.
	LatestVersion *string
	// A description of the parameters for a document.
	Parameters []*DocumentParameter
	// The name of the Systems Manager document.
	Name *string
	// The type of document.
	DocumentType DocumentType
}

type DocumentFilter struct {
	// The name of the filter.
	Key DocumentFilterKey
	// The value of the filter.
	Value *string
}

type DocumentFilterKey string

const (
	DocumentFilterKeyName          DocumentFilterKey = "Name"
	DocumentFilterKeyOwner         DocumentFilterKey = "Owner"
	DocumentFilterKeyPlatformtypes DocumentFilterKey = "PlatformTypes"
	DocumentFilterKeyDocumenttype  DocumentFilterKey = "DocumentType"
)

type DocumentFormat string

const (
	DocumentFormatYaml DocumentFormat = "YAML"
	DocumentFormatJson DocumentFormat = "JSON"
	DocumentFormatText DocumentFormat = "TEXT"
)

type DocumentHashType string

const (
	DocumentHashTypeSha256 DocumentHashType = "Sha256"
	DocumentHashTypeSha1   DocumentHashType = "Sha1"
)

type DocumentIdentifier struct {
	// The AWS user account that created the document.
	Owner *string
	// The document format, either JSON or YAML.
	DocumentFormat DocumentFormat
	// The schema version.
	SchemaVersion *string
	// A list of SSM documents required by a document. For example, an
	// ApplicationConfiguration document requires an ApplicationConfigurationSchema
	// document.
	Requires []*DocumentRequires
	// The target type which defines the kinds of resources the document can run on.
	// For example, /AWS::EC2::Instance. 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
	// The document type.
	DocumentType DocumentType
	// 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
	// The document version.
	DocumentVersion *string
	// The operating system platform.
	PlatformTypes []PlatformType
	// The tags, or metadata, that have been applied to the document.
	Tags []*Tag
	// The name of the Systems Manager document.
	Name *string
}

type DocumentKeyValuesFilter struct {
	// The value for the filter key.
	Values []*string
	// The name of the filter key.
	Key *string
}

type DocumentLimitExceeded struct {
	Message *string
}

type DocumentParameter struct {
	// A description of what the parameter does, how to use it, the default value, and
	// whether or not the parameter is optional.
	Description *string
	// The name of the parameter.
	Name *string
	// The type of parameter. The type can be either String or StringList.
	Type DocumentParameterType
	// If specified, the default values for the parameters. Parameters without a
	// default value are required. Parameters with a default value are optional.
	DefaultValue *string
}

type DocumentParameterType string

const (
	DocumentParameterTypeString     DocumentParameterType = "String"
	DocumentParameterTypeStringlist DocumentParameterType = "StringList"
)

type DocumentPermissionLimit struct {
	Message *string
}

type DocumentPermissionType string

const (
	DocumentPermissionTypeShare DocumentPermissionType = "Share"
)

type DocumentRequires struct {
	// The name of the required SSM document. The name can be an Amazon Resource Name
	// (ARN).
	Name *string
	// The document version required by the current document.
	Version *string
}

type DocumentStatus string

const (
	DocumentStatusCreating DocumentStatus = "Creating"
	DocumentStatusActive   DocumentStatus = "Active"
	DocumentStatusUpdating DocumentStatus = "Updating"
	DocumentStatusDeleting DocumentStatus = "Deleting"
	DocumentStatusFailed   DocumentStatus = "Failed"
)

type DocumentType string

const (
	DocumentTypeCommand                        DocumentType = "Command"
	DocumentTypePolicy                         DocumentType = "Policy"
	DocumentTypeAutomation                     DocumentType = "Automation"
	DocumentTypeSession                        DocumentType = "Session"
	DocumentTypePackage                        DocumentType = "Package"
	DocumentTypeApplicationconfiguration       DocumentType = "ApplicationConfiguration"
	DocumentTypeApplicationconfigurationschema DocumentType = "ApplicationConfigurationSchema"
	DocumentTypeDeploymentstrategy             DocumentType = "DeploymentStrategy"
	DocumentTypeChangecalendar                 DocumentType = "ChangeCalendar"
)

type DocumentVersionInfo struct {
	// The document version.
	DocumentVersion *string
	// The document name.
	Name *string
	// The date the document was created.
	CreatedDate *time.Time
	// The document format, either JSON or YAML.
	DocumentFormat DocumentFormat
	// The status of the Systems Manager document, such as Creating, Active, Failed,
	// and Deleting.
	Status 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
	// An identifier for the default version of the document.
	IsDefaultVersion *bool
}

type DocumentVersionLimitExceeded struct {
	Message *string
}

type DoesNotExistException struct {
	Message *string
}

type DuplicateDocumentContent struct {
	Message *string
}

type DuplicateDocumentVersionName struct {
	Message *string
}

type DuplicateInstanceId struct {
	Message *string
}

type EffectivePatch struct {
	// The status of the patch in a patch baseline. This includes information about
	// whether the patch is currently approved, due to be approved by a rule,
	// explicitly approved, or explicitly rejected and the date the patch was or will
	// be approved.
	PatchStatus *PatchStatus
	// Provides metadata for a patch, including information such as the KB ID,
	// severity, classification and a URL for where more information can be obtained
	// about the patch.
	Patch *Patch
}

type ExecutionMode string

const (
	ExecutionModeAuto        ExecutionMode = "Auto"
	ExecutionModeInteractive ExecutionMode = "Interactive"
)

type FailedCreateAssociation struct {
	// A description of the failure.
	Message *string
	// The association.
	Entry *CreateAssociationBatchRequestEntry
	// The source of the failure.
	Fault Fault
}

type FailureDetails struct {
	// Detailed information about the Automation step failure.
	Details map[string][]*string
	// The type of Automation failure. Failure types include the following: Action,
	// Permission, Throttling, Verification, Internal.
	FailureType *string
	// The stage of the Automation execution when the failure occurred. The stages
	// include the following: InputValidation, PreVerification, Invocation,
	// PostVerification.
	FailureStage *string
}

type Fault string

const (
	FaultClient  Fault = "Client"
	FaultServer  Fault = "Server"
	FaultUnknown Fault = "Unknown"
)

type FeatureNotAvailableException struct {
	Message *string
}

type HierarchyLevelLimitExceededException struct {
	Message *string
}

type HierarchyTypeMismatchException struct {
	Message *string
}

type IdempotentParameterMismatch struct {
	Message *string
}

type IncompatiblePolicyException struct {
	Message *string
}

type InstanceAggregatedAssociationOverview struct {
	// The number of associations for the instance(s).
	InstanceAssociationStatusAggregatedCount map[string]*int32
	// Detailed status information about the aggregated associations.
	DetailedStatus *string
}

type InstanceAssociation struct {
	// The instance ID.
	InstanceId *string
	// The association ID.
	AssociationId *string
	// The content of the association document for the instance(s).
	Content *string
	// Version information for the association on the instance.
	AssociationVersion *string
}

type InstanceAssociationOutputLocation struct {
	// An S3 bucket where you want to store the results of this request.
	S3Location *S3OutputLocation
}

type InstanceAssociationOutputUrl struct {
	// The URL of S3 bucket where you want to store the results of this request.
	S3OutputUrl *S3OutputUrl
}

type InstanceAssociationStatusInfo struct {
	// The instance ID where the association was created.
	InstanceId *string
	// A URL for an S3 bucket where you want to store the results of this request.
	OutputUrl *InstanceAssociationOutputUrl
	// The name of the association applied to the instance.
	AssociationName *string
	// Detailed status information about the instance association.
	DetailedStatus *string
	// The name of the association.
	Name *string
	// The version of the association applied to the instance.
	AssociationVersion *string
	// The date the instance association ran.
	ExecutionDate *time.Time
	// The association ID.
	AssociationId *string
	// Status information about the instance association.
	Status *string
	// An error code returned by the request to create the association.
	ErrorCode *string
	// The association document versions.
	DocumentVersion *string
	// Summary information about association execution.
	ExecutionSummary *string
}

type InstanceInformation struct {
	// The date the association was last run.
	LastAssociationExecutionDate *time.Time
	// The Amazon Identity and Access Management (IAM) role assigned to the on-premises
	// Systems Manager managed instance. This call does not return the IAM role for EC2
	// instances. To retrieve the IAM role for an EC2 instance, use the Amazon EC2
	// DescribeInstances action. For information, see DescribeInstances
	// (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)
	// in the Amazon EC2 API Reference or describe-instances
	// (http://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html) in
	// the AWS CLI Command Reference.
	IamRole *string
	// The activation ID created by Systems Manager when the server or VM was
	// registered.
	ActivationId *string
	// The instance ID.
	InstanceId *string
	// The version of SSM Agent running on your Linux instance.
	AgentVersion *string
	// Indicates whether the latest version of SSM Agent is running on your Linux
	// Managed Instance. This field does not indicate whether or not the latest version
	// is installed on Windows managed instances, because some older versions of
	// Windows Server use the EC2Config service to process SSM requests.
	IsLatestVersion *bool
	// The operating system platform type.
	PlatformType PlatformType
	// The status of the association.
	AssociationStatus *string
	// The IP address of the managed instance.
	IPAddress *string
	// Connection status of SSM Agent.
	PingStatus PingStatus
	// The fully qualified host name of the managed instance.
	ComputerName *string
	// The date the server or VM was registered with AWS as a managed instance.
	RegistrationDate *time.Time
	// The type of instance. Instances are either EC2 instances or managed instances.
	ResourceType ResourceType
	// The last date the association was successfully run.
	LastSuccessfulAssociationExecutionDate *time.Time
	// Information about the association.
	AssociationOverview *InstanceAggregatedAssociationOverview
	// The version of the OS platform running on your instance.
	PlatformVersion *string
	// The name of the operating system platform running on your instance.
	PlatformName *string
	// The date and time when agent last pinged Systems Manager service.
	LastPingDateTime *time.Time
	// The name assigned to an on-premises server or virtual machine (VM) when it is
	// activated as a Systems Manager managed instance. The name is specified as the
	// DefaultInstanceName property using the CreateActivation () command. It is
	// applied to the managed instance by specifying the Activation Code and Activation
	// ID when you install SSM Agent on the instance, as explained in Install SSM Agent
	// for a hybrid environment (Linux)
	// (http://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-install-managed-linux.html)
	// and Install SSM Agent for a hybrid environment (Windows)
	// (http://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-install-managed-win.html).
	// To retrieve the Name tag of an EC2 instance, use the Amazon EC2
	// DescribeInstances action. For information, see DescribeInstances
	// (http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)
	// in the Amazon EC2 API Reference or describe-instances
	// (http://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html) in
	// the AWS CLI Command Reference.
	Name *string
}

type InstanceInformationFilter struct {
	// The filter values.
	ValueSet []*string
	// The name of the filter.
	Key InstanceInformationFilterKey
}

type InstanceInformationFilterKey string

const (
	InstanceInformationFilterKeyInstance_ids       InstanceInformationFilterKey = "InstanceIds"
	InstanceInformationFilterKeyAgent_version      InstanceInformationFilterKey = "AgentVersion"
	InstanceInformationFilterKeyPing_status        InstanceInformationFilterKey = "PingStatus"
	InstanceInformationFilterKeyPlatform_types     InstanceInformationFilterKey = "PlatformTypes"
	InstanceInformationFilterKeyActivation_ids     InstanceInformationFilterKey = "ActivationIds"
	InstanceInformationFilterKeyIam_role           InstanceInformationFilterKey = "IamRole"
	InstanceInformationFilterKeyResource_type      InstanceInformationFilterKey = "ResourceType"
	InstanceInformationFilterKeyAssociation_status InstanceInformationFilterKey = "AssociationStatus"
)

type InstanceInformationStringFilter struct {
	// The filter values.
	Values []*string
	// The filter key name to describe your instances. For example:
	// "InstanceIds"|"AgentVersion"|"PingStatus"|"PlatformTypes"|"ActivationIds"|"IamRole"|"ResourceType"|"AssociationStatus"|"Tag
	// Key"
	Key *string
}

type InstancePatchState struct {
	// The number of patches from the patch baseline that are applicable for the
	// instance but aren't currently installed.
	MissingCount *int32
	// An https URL or an Amazon S3 path-style URL to a list of patches to be
	// installed. This patch installation list, which you maintain in an S3 bucket in
	// YAML format and specify in the SSM document AWS-RunPatchBaseline, overrides the
	// patches specified by the default patch baseline. For more information about the
	// InstallOverrideList parameter, see About the SSM document AWS-RunPatchBaseline
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/patch-manager-about-aws-runpatchbaseline.html)
	// in the AWS Systems Manager User Guide.
	InstallOverrideList *string
	// The ID of the patch baseline used to patch the instance.
	BaselineId *string
	// The time the most recent patching operation completed on the instance.
	OperationEndTime *time.Time
	// The time of the last attempt to patch the instance with NoReboot specified as
	// the reboot option.
	LastNoRebootInstallOperationTime *time.Time
	// The ID of the managed instance the high-level patch compliance information was
	// collected for.
	InstanceId *string
	// The number of patches not specified in the patch baseline that are installed on
	// the instance.
	InstalledOtherCount *int32
	// Placeholder information. This field will always be empty in the current release
	// of the service.
	OwnerInformation *string
	// The type of patching operation that was performed: SCAN (assess patch compliance
	// state) or INSTALL (install missing patches).
	Operation PatchOperationType
	// The number of patches installed by Patch Manager since the last time the
	// instance was rebooted.
	InstalledPendingRebootCount *int32
	// Indicates the reboot option specified in the patch baseline. Reboot options
	// apply to Install operations only. Reboots are not attempted for Patch Manager
	// Scan operations.
	//
	//     * RebootIfNeeded: Patch Manager tries to reboot the
	// instance if it installed any patches, or if any patches are detected with a
	// status of InstalledPendingReboot.
	//
	//     * NoReboot: Patch Manager attempts to
	// install missing packages without trying to reboot the system. Patches installed
	// with this option are assigned a status of InstalledPendingReboot. These patches
	// might not be in effect until a reboot is performed.
	RebootOption RebootOption
	// The ID of the patch baseline snapshot used during the patching operation when
	// this compliance data was collected.
	SnapshotId *string
	// The name of the patch group the managed instance belongs to.
	PatchGroup *string
	// The number of instances with patches installed that are specified in a
	// RejectedPatches list. Patches with a status of InstalledRejected were typically
	// installed before they were added to a RejectedPatches list. If
	// ALLOW_AS_DEPENDENCY is the specified option for RejectedPatchesAction, the value
	// of InstalledRejectedCount will always be 0 (zero).
	InstalledRejectedCount *int32
	// The number of patches from the patch baseline that aren't applicable for the
	// instance and therefore aren't installed on the instance. This number may be
	// truncated if the list of patch names is very large. The number of patches beyond
	// this limit are reported in UnreportedNotApplicableCount.
	NotApplicableCount *int32
	// The time the most recent patching operation was started on the instance.
	OperationStartTime *time.Time
	// The number of patches from the patch baseline that were attempted to be
	// installed during the last patching operation, but failed to install.
	FailedCount *int32
	// The number of patches beyond the supported limit of NotApplicableCount that are
	// not reported by name to Systems Manager Inventory.
	UnreportedNotApplicableCount *int32
	// The number of patches from the patch baseline that are installed on the
	// instance.
	InstalledCount *int32
}

type InstancePatchStateFilter struct {
	// The key for the filter. Supported values are FailedCount, InstalledCount,
	// InstalledOtherCount, MissingCount and NotApplicableCount.
	Key *string
	// The type of comparison that should be performed for the value: Equal, NotEqual,
	// LessThan or GreaterThan.
	Type InstancePatchStateOperatorType
	// The value for the filter, must be an integer greater than or equal to 0.
	Values []*string
}

type InstancePatchStateOperatorType string

const (
	InstancePatchStateOperatorTypeEqual        InstancePatchStateOperatorType = "Equal"
	InstancePatchStateOperatorTypeNot_equal    InstancePatchStateOperatorType = "NotEqual"
	InstancePatchStateOperatorTypeLess_than    InstancePatchStateOperatorType = "LessThan"
	InstancePatchStateOperatorTypeGreater_than InstancePatchStateOperatorType = "GreaterThan"
)

type InternalServerError struct {
	Message *string
}

type InvalidActivation struct {
	Message *string
}

type InvalidActivationId struct {
	Message *string
}

type InvalidAggregatorException struct {
	Message *string
}

type InvalidAllowedPatternException struct {
	Message *string
}

type InvalidAssociation struct {
	Message *string
}

type InvalidAssociationVersion struct {
	Message *string
}

type InvalidAutomationExecutionParametersException struct {
	Message *string
}

type InvalidAutomationSignalException struct {
	Message *string
}

type InvalidAutomationStatusUpdateException struct {
	Message *string
}

type InvalidCommandId struct {
	Message *string
}

type InvalidDeleteInventoryParametersException struct {
	Message *string
}

type InvalidDeletionIdException struct {
	Message *string
}

type InvalidDocument struct {
	Message *string
}

type InvalidDocumentContent struct {
	Message *string
}

type InvalidDocumentOperation struct {
	Message *string
}

type InvalidDocumentSchemaVersion struct {
	Message *string
}

type InvalidDocumentType struct {
	Message *string
}

type InvalidDocumentVersion struct {
	Message *string
}

type InvalidFilter struct {
	Message *string
}

type InvalidFilterKey struct {
	Message *string
}

type InvalidFilterOption struct {
	Message *string
}

type InvalidFilterValue struct {
	Message *string
}

type InvalidInstanceId struct {
	Message *string
}

type InvalidInstanceInformationFilterValue struct {
	Message *string
}

type InvalidInventoryGroupException struct {
	Message *string
}

type InvalidInventoryItemContextException struct {
	Message *string
}

type InvalidInventoryRequestException struct {
	Message *string
}

type InvalidItemContentException struct {
	Message *string

	TypeName *string
}

type InvalidKeyId struct {
	Message *string
}

type InvalidNextToken struct {
	Message *string
}

type InvalidNotificationConfig struct {
	Message *string
}

type InvalidOptionException struct {
	Message *string
}

type InvalidOutputFolder struct {
	Message *string
}

type InvalidOutputLocation struct {
	Message *string
}

type InvalidParameters struct {
	Message *string
}

type InvalidPermissionType struct {
	Message *string
}

type InvalidPluginName struct {
	Message *string
}

type InvalidPolicyAttributeException struct {
	Message *string
}

type InvalidPolicyTypeException struct {
	Message *string
}

type InvalidResourceId struct {
	Message *string
}

type InvalidResourceType struct {
	Message *string
}

type InvalidResultAttributeException struct {
	Message *string
}

type InvalidRole struct {
	Message *string
}

type InvalidSchedule struct {
	Message *string
}

type InvalidTarget struct {
	Message *string
}

type InvalidTypeNameException struct {
	Message *string
}

type InvalidUpdate struct {
	Message *string
}

type InventoryAggregator struct {
	// The inventory type and attribute name for aggregation.
	Expression *string
	// Nested aggregators to further refine aggregation for an inventory type.
	Aggregators []*InventoryAggregator
	// A user-defined set of one or more filters on which to aggregate inventory data.
	// Groups return a count of resources that match and don't match the specified
	// criteria.
	Groups []*InventoryGroup
}

type InventoryAttributeDataType string

const (
	InventoryAttributeDataTypeString InventoryAttributeDataType = "string"
	InventoryAttributeDataTypeNumber InventoryAttributeDataType = "number"
)

type InventoryDeletionStatus string

const (
	InventoryDeletionStatusIn_progress InventoryDeletionStatus = "InProgress"
	InventoryDeletionStatusComplete    InventoryDeletionStatus = "Complete"
)

type InventoryDeletionStatusItem struct {
	// Information about the status.
	LastStatusMessage *string
	// The deletion ID returned by the DeleteInventory action.
	DeletionId *string
	// The name of the inventory data type.
	TypeName *string
	// The status of the operation. Possible values are InProgress and Complete.
	LastStatus InventoryDeletionStatus
	// The UTC timestamp when the delete operation started.
	DeletionStartTime *time.Time
	// The UTC timestamp of when the last status report.
	LastStatusUpdateTime *time.Time
	// Information about the delete operation. For more information about this summary,
	// see Understanding the delete inventory summary
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-inventory-custom.html#sysman-inventory-delete)
	// in the AWS Systems Manager User Guide.
	DeletionSummary *InventoryDeletionSummary
}

type InventoryDeletionSummary struct {
	// The total number of items to delete. This count does not change during the
	// delete operation.
	TotalCount *int32
	// Remaining number of items to delete.
	RemainingCount *int32
	// A list of counts and versions for deleted items.
	SummaryItems []*InventoryDeletionSummaryItem
}

type InventoryDeletionSummaryItem struct {
	// The inventory type version.
	Version *string
	// The remaining number of items to delete.
	RemainingCount *int32
	// A count of the number of deleted items.
	Count *int32
}

type InventoryFilter struct {
	// The type of filter. The Exists filter must be used with aggregators. For more
	// information, see Aggregating inventory data
	// (https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-inventory-aggregate.html)
	// in the AWS Systems Manager User Guide.
	Type InventoryQueryOperatorType
	// The name of the filter key.
	Key *string
	// Inventory filter values. Example: inventory filter where instance IDs are
	// specified as values Key=AWS:InstanceInformation.InstanceId,Values=
	// i-a12b3c4d5e6g, i-1a2b3c4d5e6,Type=Equal
	Values []*string
}

type InventoryGroup struct {
	// The name of the group.
	Name *string
	// Filters define the criteria for the group. The matchingCount field displays the
	// number of resources that match the criteria. The notMatchingCount field displays
	// the number of resources that don't match the criteria.
	Filters []*InventoryFilter
}

type InventoryItem struct {
	// The schema version for the inventory item.
	SchemaVersion *string
	// The time the inventory information was collected.
	CaptureTime *string
	// The name of the inventory type. Default inventory item type names start with
	// AWS. Custom inventory type names will start with Custom. Default inventory item
	// types include the following: AWS:AWSComponent, AWS:Application,
	// AWS:InstanceInformation, AWS:Network, and AWS:WindowsUpdate.
	TypeName *string
	// A map of associated properties for a specified inventory type. For example, with
	// this attribute, you can specify the ExecutionId, ExecutionType, ComplianceType
	// properties of the AWS:ComplianceItem type.
	Context map[string]*string
	// The inventory data of the inventory type.
	Content []map[string]*string
	// MD5 hash of the inventory item type contents. The content hash is used to
	// determine whether to update inventory information. The PutInventory API does not
	// update the inventory item type contents if the MD5 hash has not changed since
	// last update.
	ContentHash *string
}