type AccountGateResult struct {

	// The reason for the account gate status assigned to this account and Region for
	// the stack set operation.
	StatusReason *string

	// The status of the account gate function.
	//
	//     * SUCCEEDED: The account gate
	// function has determined that the account and Region passes any requirements for
	// a stack set operation to occur. AWS CloudFormation proceeds with the stack
	// operation in that account and Region.
	//
	//     * FAILED: The account gate function
	// has determined that the account and Region does not meet the requirements for a
	// stack set operation to occur. AWS CloudFormation cancels the stack set operation
	// in that account and Region, and sets the stack set operation result status for
	// that account and Region to FAILED.
	//
	//     * SKIPPED: AWS CloudFormation has
	// skipped calling the account gate function for this account and Region, for one
	// of the following reasons:
	//
	//         * An account gate function has not been
	// specified for the account and Region. AWS CloudFormation proceeds with the stack
	// set operation in this account and Region.
	//
	//         * The
	// AWSCloudFormationStackSetExecutionRole of the stack set adminstration account
	// lacks permissions to invoke the function. AWS CloudFormation proceeds with the
	// stack set operation in this account and Region.
	//
	//         * Either no action is
	// necessary, or no action is possible, on the stack. AWS CloudFormation skips the
	// stack set operation in this account and Region.
	Status AccountGateStatus
}

type AccountGateStatus string

const (
	AccountGateStatusSucceeded AccountGateStatus = "SUCCEEDED"
	AccountGateStatusFailed    AccountGateStatus = "FAILED"
	AccountGateStatusSkipped   AccountGateStatus = "SKIPPED"
)

type AccountLimit struct {

	// The name of the account limit. Values: ConcurrentResourcesLimit | StackLimit |
	// StackOutputsLimit
	Name *string

	// The value that is associated with the account limit name.
	Value *int32
}

type AlreadyExistsException struct {
	Message *string
}

type AutoDeployment struct {

	// If set to true, stack resources are retained when an account is removed from a
	// target organization or OU. If set to false, stack resources are deleted. Specify
	// only if Enabled is set to True.
	RetainStacksOnAccountRemoval *bool

	// If set to true, StackSets automatically deploys additional stack instances to
	// AWS Organizations accounts that are added to a target organization or
	// organizational unit (OU) in the specified Regions. If an account is removed from
	// a target organization or OU, StackSets deletes stack instances from the account
	// in the specified Regions.
	Enabled *bool
}

type CFNRegistryException struct {
	Message *string
}

type Capability string

const (
	CapabilityCapability_iam         Capability = "CAPABILITY_IAM"
	CapabilityCapability_named_iam   Capability = "CAPABILITY_NAMED_IAM"
	CapabilityCapability_auto_expand Capability = "CAPABILITY_AUTO_EXPAND"
)

type Change struct {

	// A ResourceChange structure that describes the resource and action that AWS
	// CloudFormation will perform.
	ResourceChange *ResourceChange

	// The type of entity that AWS CloudFormation changes. Currently, the only entity
	// type is Resource.
	Type ChangeType
}

type ChangeAction string

const (
	ChangeActionAdd    ChangeAction = "Add"
	ChangeActionModify ChangeAction = "Modify"
	ChangeActionRemove ChangeAction = "Remove"
	ChangeActionImport ChangeAction = "Import"
)

type ChangeSetNotFoundException struct {
	Message *string
}

type ChangeSetStatus string

const (
	ChangeSetStatusCreate_pending     ChangeSetStatus = "CREATE_PENDING"
	ChangeSetStatusCreate_in_progress ChangeSetStatus = "CREATE_IN_PROGRESS"
	ChangeSetStatusCreate_complete    ChangeSetStatus = "CREATE_COMPLETE"
	ChangeSetStatusDelete_complete    ChangeSetStatus = "DELETE_COMPLETE"
	ChangeSetStatusFailed             ChangeSetStatus = "FAILED"
)

type ChangeSetSummary struct {

	// The state of the change set, such as CREATE_IN_PROGRESS, CREATE_COMPLETE, or
	// FAILED.
	Status ChangeSetStatus

	// A description of the change set's status. For example, if your change set is in
	// the FAILED state, AWS CloudFormation shows the error message.
	StatusReason *string

	// Descriptive information about the change set.
	Description *string

	// The ID of the change set.
	ChangeSetId *string

	// If the change set execution status is AVAILABLE, you can execute the change set.
	// If you can’t execute the change set, the status indicates why. For example, a
	// change set might be in an UNAVAILABLE state because AWS CloudFormation is still
	// creating it or in an OBSOLETE state because the stack was already updated.
	ExecutionStatus ExecutionStatus

	// The name of the change set.
	ChangeSetName *string

	// The name of the stack with which the change set is associated.
	StackName *string

	// The ID of the stack with which the change set is associated.
	StackId *string

	// The start time when the change set was created, in UTC.
	CreationTime *time.Time
}

type ChangeSetType string

const (
	ChangeSetTypeCreate ChangeSetType = "CREATE"
	ChangeSetTypeUpdate ChangeSetType = "UPDATE"
	ChangeSetTypeImport ChangeSetType = "IMPORT"
)

type ChangeSource string

const (
	ChangeSourceResourcereference  ChangeSource = "ResourceReference"
	ChangeSourceParameterreference ChangeSource = "ParameterReference"
	ChangeSourceResourceattribute  ChangeSource = "ResourceAttribute"
	ChangeSourceDirectmodification ChangeSource = "DirectModification"
	ChangeSourceAutomatic          ChangeSource = "Automatic"
)

type ChangeType string

const (
	ChangeTypeResource ChangeType = "Resource"
)

type CreatedButModifiedException struct {
	Message *string
}

type DeploymentTargets struct {

	// The names of one or more AWS accounts for which you want to deploy stack set
	// updates.
	Accounts []*string

	// The organization root ID or organizational unit (OU) IDs to which StackSets
	// deploys.
	OrganizationalUnitIds []*string
}

type DeprecatedStatus string

const (
	DeprecatedStatusLive       DeprecatedStatus = "LIVE"
	DeprecatedStatusDeprecated DeprecatedStatus = "DEPRECATED"
)

type DifferenceType string

const (
	DifferenceTypeAdd       DifferenceType = "ADD"
	DifferenceTypeRemove    DifferenceType = "REMOVE"
	DifferenceTypeNot_equal DifferenceType = "NOT_EQUAL"
)

type EvaluationType string

const (
	EvaluationTypeStatic  EvaluationType = "Static"
	EvaluationTypeDynamic EvaluationType = "Dynamic"
)

type ExecutionStatus string

const (
	ExecutionStatusUnavailable         ExecutionStatus = "UNAVAILABLE"
	ExecutionStatusAvailable           ExecutionStatus = "AVAILABLE"
	ExecutionStatusExecute_in_progress ExecutionStatus = "EXECUTE_IN_PROGRESS"
	ExecutionStatusExecute_complete    ExecutionStatus = "EXECUTE_COMPLETE"
	ExecutionStatusExecute_failed      ExecutionStatus = "EXECUTE_FAILED"
	ExecutionStatusObsolete            ExecutionStatus = "OBSOLETE"
)

type Export struct {

	// The name of exported output value. Use this name and the Fn::ImportValue
	// function to import the associated value into other stacks. The name is defined
	// in the Export field in the associated stack's Outputs section.
	Name *string

	// The value of the exported output, such as a resource physical ID. This value is
	// defined in the Export field in the associated stack's Outputs section.
	Value *string

	// The stack that contains the exported output name and value.
	ExportingStackId *string
}

type HandlerErrorCode string

const (
	HandlerErrorCodeNotupdatable            HandlerErrorCode = "NotUpdatable"
	HandlerErrorCodeInvalidrequest          HandlerErrorCode = "InvalidRequest"
	HandlerErrorCodeAccessdenied            HandlerErrorCode = "AccessDenied"
	HandlerErrorCodeInvalidcredentials      HandlerErrorCode = "InvalidCredentials"
	HandlerErrorCodeAlreadyexists           HandlerErrorCode = "AlreadyExists"
	HandlerErrorCodeNotfound                HandlerErrorCode = "NotFound"
	HandlerErrorCodeResourceconflict        HandlerErrorCode = "ResourceConflict"
	HandlerErrorCodeThrottling              HandlerErrorCode = "Throttling"
	HandlerErrorCodeServicelimitexceeded    HandlerErrorCode = "ServiceLimitExceeded"
	HandlerErrorCodeServicetimeout          HandlerErrorCode = "NotStabilized"
	HandlerErrorCodeGeneralserviceexception HandlerErrorCode = "GeneralServiceException"
	HandlerErrorCodeServiceinternalerror    HandlerErrorCode = "ServiceInternalError"
	HandlerErrorCodeNetworkfailure          HandlerErrorCode = "NetworkFailure"
	HandlerErrorCodeInternalfailure         HandlerErrorCode = "InternalFailure"
)

type InsufficientCapabilitiesException struct {
	Message *string
}

type InvalidChangeSetStatusException struct {
	Message *string
}

type InvalidOperationException struct {
	Message *string
}

type InvalidStateTransitionException struct {
	Message *string
}

type LimitExceededException struct {
	Message *string
}

type LoggingConfig struct {

	// The ARN of the role that CloudFormation should assume when sending log entries
	// to CloudWatch logs.
	//
	// This member is required.
	LogRoleArn *string

	// The Amazon CloudWatch log group to which CloudFormation sends error logging
	// information when invoking the type's handlers.
	//
	// This member is required.
	LogGroupName *string
}

type NameAlreadyExistsException struct {
	Message *string
}

type OnFailure string

const (
	OnFailureDo_nothing OnFailure = "DO_NOTHING"
	OnFailureRollback   OnFailure = "ROLLBACK"
	OnFailureDelete     OnFailure = "DELETE"
)

type OperationIdAlreadyExistsException struct {
	Message *string
}

type OperationInProgressException struct {
	Message *string
}

type OperationNotFoundException struct {
	Message *string
}

type OperationStatus string

const (
	OperationStatusPending     OperationStatus = "PENDING"
	OperationStatusIn_progress OperationStatus = "IN_PROGRESS"
	OperationStatusSuccess     OperationStatus = "SUCCESS"
	OperationStatusFailed      OperationStatus = "FAILED"
)

type OperationStatusCheckFailedException struct {
	Message *string
}

type Output struct {

	// The value associated with the output.
	OutputValue *string

	// The key associated with the output.
	OutputKey *string

	// The name of the export associated with the output.
	ExportName *string

	// User defined description associated with the output.
	Description *string
}

type Parameter struct {

	// The key associated with the parameter. If you don't specify a key and value for
	// a particular parameter, AWS CloudFormation uses the default value that is
	// specified in your template.
	ParameterKey *string

	// Read-only. The value that corresponds to a Systems Manager parameter key. This
	// field is returned only for SSM parameter types
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types)
	// in the template.
	ResolvedValue *string

	// The input value associated with the parameter.
	ParameterValue *string

	// During a stack update, use the existing parameter value that the stack is using
	// for a given parameter key. If you specify true, do not specify a parameter
	// value.
	UsePreviousValue *bool
}

type ParameterConstraints struct {

	// A list of values that are permitted for a parameter.
	AllowedValues []*string
}

type ParameterDeclaration struct {

	// The criteria that AWS CloudFormation uses to validate parameter values.
	ParameterConstraints *ParameterConstraints

	// The description that is associate with the parameter.
	Description *string

	// The type of parameter.
	ParameterType *string

	// Flag that indicates whether the parameter value is shown as plain text in logs
	// and in the AWS Management Console.
	NoEcho *bool

	// The default value of the parameter.
	DefaultValue *string

	// The name that is associated with the parameter.
	ParameterKey *string
}

type PermissionModels string

const (
	PermissionModelsService_managed PermissionModels = "SERVICE_MANAGED"
	PermissionModelsSelf_managed    PermissionModels = "SELF_MANAGED"
)

type PhysicalResourceIdContextKeyValuePair struct {

	// The resource context value.
	//
	// This member is required.
	Value *string

	// The resource context key.
	//
	// This member is required.
	Key *string
}

type PropertyDifference struct {

	// The fully-qualified path to the resource property.
	//
	// This member is required.
	PropertyPath *string

	// The expected property value of the resource property, as defined in the stack
	// template and any values specified as template parameters.
	//
	// This member is required.
	ExpectedValue *string

	// The actual property value of the resource property.
	//
	// This member is required.
	ActualValue *string

	// The type of property difference.
	//
	//     * ADD: A value has been added to a
	// resource property that is an array or list data type.
	//
	//     * REMOVE: The
	// property has been removed from the current resource configuration.
	//
	//     *
	// NOT_EQUAL: The current property value differs from its expected value (as
	// defined in the stack template and any values specified as template parameters).
	//
	// This member is required.
	DifferenceType DifferenceType
}

type ProvisioningType string

const (
	ProvisioningTypeNon_provisionable ProvisioningType = "NON_PROVISIONABLE"
	ProvisioningTypeImmutable         ProvisioningType = "IMMUTABLE"
	ProvisioningTypeFully_mutable     ProvisioningType = "FULLY_MUTABLE"
)

type RegistrationStatus string

const (
	RegistrationStatusComplete    RegistrationStatus = "COMPLETE"
	RegistrationStatusIn_progress RegistrationStatus = "IN_PROGRESS"
	RegistrationStatusFailed      RegistrationStatus = "FAILED"
)

type RegistryType string

const (
	RegistryTypeResource RegistryType = "RESOURCE"
)

type Replacement string

const (
	ReplacementTrue        Replacement = "True"
	ReplacementFalse       Replacement = "False"
	ReplacementConditional Replacement = "Conditional"
)

type RequiresRecreation string

const (
	RequiresRecreationNever         RequiresRecreation = "Never"
	RequiresRecreationConditionally RequiresRecreation = "Conditionally"
	RequiresRecreationAlways        RequiresRecreation = "Always"
)

type ResourceAttribute string

const (
	ResourceAttributeProperties     ResourceAttribute = "Properties"
	ResourceAttributeMetadata       ResourceAttribute = "Metadata"
	ResourceAttributeCreationpolicy ResourceAttribute = "CreationPolicy"
	ResourceAttributeUpdatepolicy   ResourceAttribute = "UpdatePolicy"
	ResourceAttributeDeletionpolicy ResourceAttribute = "DeletionPolicy"
	ResourceAttributeTags           ResourceAttribute = "Tags"
)

type ResourceChange struct {

	// The resource's physical ID (resource name). Resources that you are adding don't
	// have physical IDs because they haven't been created.
	PhysicalResourceId *string

	// For the Modify action, indicates whether AWS CloudFormation will replace the
	// resource by creating a new one and deleting the old one. This value depends on
	// the value of the RequiresRecreation property in the ResourceTargetDefinition
	// structure. For example, if the RequiresRecreation field is Always and the
	// Evaluation field is Static, Replacement is True. If the RequiresRecreation field
	// is Always and the Evaluation field is Dynamic, Replacement is Conditionally. If
	// you have multiple changes with different RequiresRecreation values, the
	// Replacement value depends on the change with the most impact. A
	// RequiresRecreation value of Always has the most impact, followed by
	// Conditionally, and then Never.
	Replacement Replacement

	// The action that AWS CloudFormation takes on the resource, such as Add (adds a
	// new resource), Modify (changes a resource), or Remove (deletes a resource).
	Action ChangeAction

	// The type of AWS CloudFormation resource, such as AWS::S3::Bucket.
	ResourceType *string

	// For the Modify action, indicates which resource attribute is triggering this
	// update, such as a change in the resource attribute's Metadata, Properties, or
	// Tags.
	Scope []ResourceAttribute

	// For the Modify action, a list of ResourceChangeDetail structures that describes
	// the changes that AWS CloudFormation will make to the resource.
	Details []*ResourceChangeDetail

	// The resource's logical ID, which is defined in the stack's template.
	LogicalResourceId *string
}

type ResourceChangeDetail struct {

	// The group to which the CausingEntity value belongs. There are five entity
	// groups:
	//
	//     * ResourceReference entities are Ref intrinsic functions that refer
	// to resources in the template, such as { "Ref" : "MyEC2InstanceResource" }.
	//
	//
	// * ParameterReference entities are Ref intrinsic functions that get template
	// parameter values, such as { "Ref" : "MyPasswordParameter" }.
	//
	//     *
	// ResourceAttribute entities are Fn::GetAtt intrinsic functions that get resource
	// attribute values, such as { "Fn::GetAtt" : [ "MyEC2InstanceResource",
	// "PublicDnsName" ] }.
	//
	//     * DirectModification entities are changes that are
	// made directly to the template.
	//
	//     * Automatic entities are
	// AWS::CloudFormation::Stack resource types, which are also known as nested
	// stacks. If you made no changes to the AWS::CloudFormation::Stack resource, AWS
	// CloudFormation sets the ChangeSource to Automatic because the nested stack's
	// template might have changed. Changes to a nested stack's template aren't visible
	// to AWS CloudFormation until you run an update on the parent stack.
	ChangeSource ChangeSource

	// The identity of the entity that triggered this change. This entity is a member
	// of the group that is specified by the ChangeSource field. For example, if you
	// modified the value of the KeyPairName parameter, the CausingEntity is the name
	// of the parameter (KeyPairName). If the ChangeSource value is DirectModification,
	// no value is given for CausingEntity.
	CausingEntity *string

	// A ResourceTargetDefinition structure that describes the field that AWS
	// CloudFormation will change and whether the resource will be recreated.
	Target *ResourceTargetDefinition

	// Indicates whether AWS CloudFormation can determine the target value, and whether
	// the target value will change before you execute a change set. For Static
	// evaluations, AWS CloudFormation can determine that the target value will change,
	// and its value. For example, if you directly modify the InstanceType property of
	// an EC2 instance, AWS CloudFormation knows that this property value will change,
	// and its value, so this is a Static evaluation. For Dynamic evaluations, cannot
	// determine the target value because it depends on the result of an intrinsic
	// function, such as a Ref or Fn::GetAtt intrinsic function, when the stack is
	// updated. For example, if your template includes a reference to a resource that
	// is conditionally recreated, the value of the reference (the physical ID of the
	// resource) might change, depending on if the resource is recreated. If the
	// resource is recreated, it will have a new physical ID, so all references to that
	// resource will also be updated.
	Evaluation EvaluationType
}

type ResourceIdentifierSummary struct {

	// The logical IDs of the target resources of the specified ResourceType, as
	// defined in the import template.
	LogicalResourceIds []*string

	// The resource properties you can provide during the import to identify your
	// target resources. For example, BucketName is a possible identifier property for
	// AWS::S3::Bucket resources.
	ResourceIdentifiers []*string

	// The template resource type of the target resources, such as AWS::S3::Bucket.
	ResourceType *string
}

type ResourceSignalStatus string

const (
	ResourceSignalStatusSuccess ResourceSignalStatus = "SUCCESS"
	ResourceSignalStatusFailure ResourceSignalStatus = "FAILURE"
)

type ResourceStatus string

const (
	ResourceStatusCreate_in_progress          ResourceStatus = "CREATE_IN_PROGRESS"
	ResourceStatusCreate_failed               ResourceStatus = "CREATE_FAILED"
	ResourceStatusCreate_complete             ResourceStatus = "CREATE_COMPLETE"
	ResourceStatusDelete_in_progress          ResourceStatus = "DELETE_IN_PROGRESS"
	ResourceStatusDelete_failed               ResourceStatus = "DELETE_FAILED"
	ResourceStatusDelete_complete             ResourceStatus = "DELETE_COMPLETE"
	ResourceStatusDelete_skipped              ResourceStatus = "DELETE_SKIPPED"
	ResourceStatusUpdate_in_progress          ResourceStatus = "UPDATE_IN_PROGRESS"
	ResourceStatusUpdate_failed               ResourceStatus = "UPDATE_FAILED"
	ResourceStatusUpdate_complete             ResourceStatus = "UPDATE_COMPLETE"
	ResourceStatusImport_failed               ResourceStatus = "IMPORT_FAILED"
	ResourceStatusImport_complete             ResourceStatus = "IMPORT_COMPLETE"
	ResourceStatusImport_in_progress          ResourceStatus = "IMPORT_IN_PROGRESS"
	ResourceStatusImport_rollback_in_progress ResourceStatus = "IMPORT_ROLLBACK_IN_PROGRESS"
	ResourceStatusImport_rollback_failed      ResourceStatus = "IMPORT_ROLLBACK_FAILED"
	ResourceStatusImport_rollback_complete    ResourceStatus = "IMPORT_ROLLBACK_COMPLETE"
)

type ResourceTargetDefinition struct {

	// If the Attribute value is Properties, the name of the property. For all other
	// attributes, the value is null.
	Name *string

	// If the Attribute value is Properties, indicates whether a change to this
	// property causes the resource to be recreated. The value can be Never, Always, or
	// Conditionally. To determine the conditions for a Conditionally recreation, see
	// the update behavior for that property
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
	// in the AWS CloudFormation User Guide.
	RequiresRecreation RequiresRecreation

	// Indicates which resource attribute is triggering this update, such as a change
	// in the resource attribute's Metadata, Properties, or Tags.
	Attribute ResourceAttribute
}

type ResourceToImport struct {

	// The logical ID of the target resource as specified in the template.
	//
	// This member is required.
	LogicalResourceId *string

	// A key-value pair that identifies the target resource. The key is an identifier
	// property (for example, BucketName for AWS::S3::Bucket resources) and the value
	// is the actual property value (for example, MyS3Bucket).
	//
	// This member is required.
	ResourceIdentifier map[string]*string

	// The type of resource to import into your stack, such as AWS::S3::Bucket. For a
	// list of supported resource types, see Resources that support import operations
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-import-supported-resources.html)
	// in the AWS CloudFormation User Guide.
	//
	// This member is required.
	ResourceType *string
}

type RollbackConfiguration struct {

	// The triggers to monitor during stack creation or update actions. By default, AWS
	// CloudFormation saves the rollback triggers specified for a stack and applies
	// them to any subsequent update operations for the stack, unless you specify
	// otherwise. If you do specify rollback triggers for this parameter, those
	// triggers replace any list of triggers previously specified for the stack. This
	// means:
	//
	//     * To use the rollback triggers previously specified for this stack,
	// if any, don't specify this parameter.
	//
	//     * To specify new or updated rollback
	// triggers, you must specify all the triggers that you want used for this stack,
	// even triggers you've specifed before (for example, when creating the stack or
	// during a previous stack update). Any triggers that you don't include in the
	// updated list of triggers are no longer applied to the stack.
	//
	//     * To remove
	// all currently specified triggers, specify an empty list for this parameter.
	//
	// If
	// a specified trigger is missing, the entire stack operation fails and is rolled
	// back.
	RollbackTriggers []*RollbackTrigger

	// The amount of time, in minutes, during which CloudFormation should monitor all
	// the rollback triggers after the stack creation or update operation deploys all
	// necessary resources. The default is 0 minutes. If you specify a monitoring
	// period but do not specify any rollback triggers, CloudFormation still waits the
	// specified period of time before cleaning up old resources after update
	// operations. You can use this monitoring period to perform any manual stack
	// validation desired, and manually cancel the stack creation or update (using
	// CancelUpdateStack
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CancelUpdateStack.html),
	// for example) as necessary. If you specify 0 for this parameter, CloudFormation
	// still monitors the specified rollback triggers during stack creation and update
	// operations. Then, for update operations, it begins disposing of old resources
	// immediately once the operation completes.
	MonitoringTimeInMinutes *int32
}

type RollbackTrigger struct {

	// The resource type of the rollback trigger. Currently, AWS::CloudWatch::Alarm
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cw-alarm.html)
	// is the only supported resource type.
	//
	// This member is required.
	Type *string

	// The Amazon Resource Name (ARN) of the rollback trigger. If a specified trigger
	// is missing, the entire stack operation fails and is rolled back.
	//
	// This member is required.
	Arn *string
}

type Stack struct {

	// A list of output structures.
	Outputs []*Output

	// A list of Parameter structures.
	Parameters []*Parameter

	// The rollback triggers for AWS CloudFormation to monitor during stack creation
	// and updating operations, and for the specified monitoring period afterwards.
	RollbackConfiguration *RollbackConfiguration

	// The time the stack was deleted.
	DeletionTime *time.Time

	// The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that is associated with the stack. During a stack operation, AWS
	// CloudFormation uses this role's credentials to make calls on your behalf.
	RoleARN *string

	// Whether termination protection is enabled for the stack. For nested stacks
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html),
	// termination protection is set on the root stack and cannot be changed directly
	// on the nested stack. For more information, see Protecting a Stack From Being
	// Deleted
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html)
	// in the AWS CloudFormation User Guide.
	EnableTerminationProtection *bool

	// Boolean to enable or disable rollback on stack creation failures:
	//
	//     * true:
	// disable rollback
	//
	//     * false: enable rollback
	DisableRollback *bool

	// The time at which the stack was created.
	//
	// This member is required.
	CreationTime *time.Time

	// The time the stack was last updated. This field will only be returned if the
	// stack has been updated at least once.
	LastUpdatedTime *time.Time

	// Success/failure message associated with the stack status.
	StackStatusReason *string

	// The capabilities allowed in the stack.
	Capabilities []Capability

	// Current status of the stack.
	//
	// This member is required.
	StackStatus StackStatus

	// A user-defined description associated with the stack.
	Description *string

	// For nested stacks--stacks created as resources for another stack--the stack ID
	// of the top-level stack to which the nested stack ultimately belongs. For more
	// information, see Working with Nested Stacks
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
	// in the AWS CloudFormation User Guide.
	RootId *string

	// For nested stacks--stacks created as resources for another stack--the stack ID
	// of the direct parent of this stack. For the first level of nested stacks, the
	// root stack is also the parent stack. For more information, see Working with
	// Nested Stacks
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
	// in the AWS CloudFormation User Guide.
	ParentId *string

	// SNS topic ARNs to which stack related events are published.
	NotificationARNs []*string

	// The unique ID of the change set.
	ChangeSetId *string

	// A list of Tags that specify information about the stack.
	Tags []*Tag

	// The amount of time within which stack creation should complete.
	TimeoutInMinutes *int32

	// The name associated with the stack.
	//
	// This member is required.
	StackName *string

	// Unique identifier of the stack.
	StackId *string

	// Information on whether a stack's actual configuration differs, or has drifted,
	// from it's expected configuration, as defined in the stack template and any
	// values specified as template parameters. For more information, see Detecting
	// Unregulated Configuration Changes to Stacks and Resources
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).
	DriftInformation *StackDriftInformation
}

type StackDriftDetectionStatus string

const (
	StackDriftDetectionStatusDetection_in_progress StackDriftDetectionStatus = "DETECTION_IN_PROGRESS"
	StackDriftDetectionStatusDetection_failed      StackDriftDetectionStatus = "DETECTION_FAILED"
	StackDriftDetectionStatusDetection_complete    StackDriftDetectionStatus = "DETECTION_COMPLETE"
)

type StackDriftInformation struct {

	// Most recent time when a drift detection operation was initiated on the stack, or
	// any of its individual resources that support drift detection.
	LastCheckTimestamp *time.Time

	// Status of the stack's actual configuration compared to its expected template
	// configuration.
	//
	//     * DRIFTED: The stack differs from its expected template
	// configuration. A stack is considered to have drifted if one or more of its
	// resources have drifted.
	//
	//     * NOT_CHECKED: AWS CloudFormation has not checked
	// if the stack differs from its expected template configuration.
	//
	//     * IN_SYNC:
	// The stack's actual configuration matches its expected template configuration.
	//
	//
	// * UNKNOWN: This value is reserved for future use.
	//
	// This member is required.
	StackDriftStatus StackDriftStatus
}

type StackDriftInformationSummary struct {

	// Status of the stack's actual configuration compared to its expected template
	// configuration.
	//
	//     * DRIFTED: The stack differs from its expected template
	// configuration. A stack is considered to have drifted if one or more of its
	// resources have drifted.
	//
	//     * NOT_CHECKED: AWS CloudFormation has not checked
	// if the stack differs from its expected template configuration.
	//
	//     * IN_SYNC:
	// The stack's actual configuration matches its expected template configuration.
	//
	//
	// * UNKNOWN: This value is reserved for future use.
	//
	// This member is required.
	StackDriftStatus StackDriftStatus

	// Most recent time when a drift detection operation was initiated on the stack, or
	// any of its individual resources that support drift detection.
	LastCheckTimestamp *time.Time
}

type StackDriftStatus string

const (
	StackDriftStatusDrifted     StackDriftStatus = "DRIFTED"
	StackDriftStatusIn_sync     StackDriftStatus = "IN_SYNC"
	StackDriftStatusUnknown     StackDriftStatus = "UNKNOWN"
	StackDriftStatusNot_checked StackDriftStatus = "NOT_CHECKED"
)

type StackEvent struct {

	// The token passed to the operation that generated this event. All events
	// triggered by a given stack operation are assigned the same client request token,
	// which you can use to track operations. For example, if you execute a CreateStack
	// operation with the token token1, then all the StackEvents generated by that
	// operation will have ClientRequestToken set as token1. In the console, stack
	// operations display the client request token on the Events tab. Stack operations
	// that are initiated from the console use the token format
	// Console-StackOperation-ID, which helps you easily identify the stack operation .
	// For example, if you create a stack using the console, each stack event would be
	// assigned the same token in the following format:
	// Console-CreateStack-7f59c3cf-00d2-40c7-b2ff-e75db0987002.
	ClientRequestToken *string

	// Success/failure message associated with the resource.
	ResourceStatusReason *string

	// The logical name of the resource specified in the template.
	LogicalResourceId *string

	// BLOB of the properties used to create the resource.
	ResourceProperties *string

	// Time the status was updated.
	//
	// This member is required.
	Timestamp *time.Time

	// The name associated with a stack.
	//
	// This member is required.
	StackName *string

	// The unique ID name of the instance of the stack.
	//
	// This member is required.
	StackId *string

	// The unique ID of this event.
	//
	// This member is required.
	EventId *string

	// Current status of the resource.
	ResourceStatus ResourceStatus

	// Type of resource. (For more information, go to  AWS Resource Types Reference
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
	// in the AWS CloudFormation User Guide.)
	ResourceType *string

	// The name or unique identifier associated with the physical instance of the
	// resource.
	PhysicalResourceId *string
}

type StackInstance struct {

	// The name of the AWS Region that the stack instance is associated with.
	Region *string

	// Status of the stack instance's actual configuration compared to the expected
	// template and parameter configuration of the stack set to which it belongs.
	//
	//
	// * DRIFTED: The stack differs from the expected template and parameter
	// configuration of the stack set to which it belongs. A stack instance is
	// considered to have drifted if one or more of the resources in the associated
	// stack have drifted.
	//
	//     * NOT_CHECKED: AWS CloudFormation has not checked if
	// the stack instance differs from its expected stack set configuration.
	//
	//     *
	// IN_SYNC: The stack instance's actual configuration matches its expected stack
	// set configuration.
	//
	//     * UNKNOWN: This value is reserved for future use.
	DriftStatus StackDriftStatus

	// A list of parameters from the stack set template whose values have been
	// overridden in this stack instance.
	ParameterOverrides []*Parameter

	// The explanation for the specific status code that is assigned to this stack
	// instance.
	StatusReason *string

	// The ID of the stack instance.
	StackId *string

	// Most recent time when CloudFormation performed a drift detection operation on
	// the stack instance. This value will be NULL for any stack instance on which
	// drift detection has not yet been performed.
	LastDriftCheckTimestamp *time.Time

	// The status of the stack instance, in terms of its synchronization with its
	// associated stack set.
	//
	//     * INOPERABLE: A DeleteStackInstances operation has
	// failed and left the stack in an unstable state. Stacks in this state are
	// excluded from further UpdateStackSet operations. You might need to perform a
	// DeleteStackInstances operation, with RetainStacks set to true, to delete the
	// stack instance, and then delete the stack manually.
	//
	//     * OUTDATED: The stack
	// isn't currently up to date with the stack set because:
	//
	//         * The associated
	// stack failed during a CreateStackSet or UpdateStackSet operation.
	//
	//         * The
	// stack was part of a CreateStackSet or UpdateStackSet operation that failed or
	// was stopped before the stack was created or updated.
	//
	//     * CURRENT: The stack
	// is currently up to date with the stack set.
	Status StackInstanceStatus

	// [Service-managed permissions] The organization root ID or organizational unit
	// (OU) IDs that you specified for DeploymentTargets
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeploymentTargets.html).
	OrganizationalUnitId *string

	// The name or unique ID of the stack set that the stack instance is associated
	// with.
	StackSetId *string

	// [Self-managed permissions] The name of the AWS account that the stack instance
	// is associated with.
	Account *string

	// The detailed status of the stack instance.
	StackInstanceStatus *StackInstanceComprehensiveStatus
}

type StackInstanceComprehensiveStatus struct {

	// * CANCELLED: The operation in the specified account and Region has been
	// cancelled. This is either because a user has stopped the stack set operation, or
	// because the failure tolerance of the stack set operation has been exceeded.
	//
	//
	// * FAILED: The operation in the specified account and Region failed. If the stack
	// set operation fails in enough accounts within a Region, the failure tolerance
	// for the stack set operation as a whole might be exceeded.
	//
	//     * INOPERABLE: A
	// DeleteStackInstances operation has failed and left the stack in an unstable
	// state. Stacks in this state are excluded from further UpdateStackSet operations.
	// You might need to perform a DeleteStackInstances operation, with RetainStacks
	// set to true, to delete the stack instance, and then delete the stack manually.
	//
	//
	// * PENDING: The operation in the specified account and Region has yet to start.
	//
	//
	// * RUNNING: The operation in the specified account and Region is currently in
	// progress.
	//
	//     * SUCCEEDED: The operation in the specified account and Region
	// completed successfully.
	DetailedStatus StackInstanceDetailedStatus
}

type StackInstanceDetailedStatus string

const (
	StackInstanceDetailedStatusPending    StackInstanceDetailedStatus = "PENDING"
	StackInstanceDetailedStatusRunning    StackInstanceDetailedStatus = "RUNNING"
	StackInstanceDetailedStatusSucceeded  StackInstanceDetailedStatus = "SUCCEEDED"
	StackInstanceDetailedStatusFailed     StackInstanceDetailedStatus = "FAILED"
	StackInstanceDetailedStatusCancelled  StackInstanceDetailedStatus = "CANCELLED"
	StackInstanceDetailedStatusInoperable StackInstanceDetailedStatus = "INOPERABLE"
)

type StackInstanceFilter struct {

	// The type of filter to apply.
	Name StackInstanceFilterName

	// The status to filter by.
	Values *string
}

type StackInstanceFilterName string

const (
	StackInstanceFilterNameDetailed_status StackInstanceFilterName = "DETAILED_STATUS"
)

type StackInstanceNotFoundException struct {
	Message *string
}

type StackInstanceStatus string

const (
	StackInstanceStatusCurrent    StackInstanceStatus = "CURRENT"
	StackInstanceStatusOutdated   StackInstanceStatus = "OUTDATED"
	StackInstanceStatusInoperable StackInstanceStatus = "INOPERABLE"
)

type StackInstanceSummary struct {

	// The status of the stack instance, in terms of its synchronization with its
	// associated stack set.
	//
	//     * INOPERABLE: A DeleteStackInstances operation has
	// failed and left the stack in an unstable state. Stacks in this state are
	// excluded from further UpdateStackSet operations. You might need to perform a
	// DeleteStackInstances operation, with RetainStacks set to true, to delete the
	// stack instance, and then delete the stack manually.
	//
	//     * OUTDATED: The stack
	// isn't currently up to date with the stack set because:
	//
	//         * The associated
	// stack failed during a CreateStackSet or UpdateStackSet operation.
	//
	//         * The
	// stack was part of a CreateStackSet or UpdateStackSet operation that failed or
	// was stopped before the stack was created or updated.
	//
	//     * CURRENT: The stack
	// is currently up to date with the stack set.
	Status StackInstanceStatus

	// The explanation for the specific status code assigned to this stack instance.
	StatusReason *string

	// Most recent time when CloudFormation performed a drift detection operation on
	// the stack instance. This value will be NULL for any stack instance on which
	// drift detection has not yet been performed.
	LastDriftCheckTimestamp *time.Time

	// [Service-managed permissions] The organization root ID or organizational unit
	// (OU) IDs that you specified for DeploymentTargets
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeploymentTargets.html).
	OrganizationalUnitId *string

	// The name or unique ID of the stack set that the stack instance is associated
	// with.
	StackSetId *string

	// [Self-managed permissions] The name of the AWS account that the stack instance
	// is associated with.
	Account *string

	// The detailed status of the stack instance.
	StackInstanceStatus *StackInstanceComprehensiveStatus

	// Status of the stack instance's actual configuration compared to the expected
	// template and parameter configuration of the stack set to which it belongs.
	//
	//
	// * DRIFTED: The stack differs from the expected template and parameter
	// configuration of the stack set to which it belongs. A stack instance is
	// considered to have drifted if one or more of the resources in the associated
	// stack have drifted.
	//
	//     * NOT_CHECKED: AWS CloudFormation has not checked if
	// the stack instance differs from its expected stack set configuration.
	//
	//     *
	// IN_SYNC: The stack instance's actual configuration matches its expected stack
	// set configuration.
	//
	//     * UNKNOWN: This value is reserved for future use.
	DriftStatus StackDriftStatus

	// The ID of the stack instance.
	StackId *string

	// The name of the AWS Region that the stack instance is associated with.
	Region *string
}

type StackResource struct {

	// The logical name of the resource specified in the template.
	//
	// This member is required.
	LogicalResourceId *string

	// Success/failure message associated with the resource.
	ResourceStatusReason *string

	// User defined description associated with the resource.
	Description *string

	// Information about whether the resource's actual configuration differs, or has
	// drifted, from its expected configuration, as defined in the stack template and
	// any values specified as template parameters. For more information, see Detecting
	// Unregulated Configuration Changes to Stacks and Resources
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).
	DriftInformation *StackResourceDriftInformation

	// The name or unique identifier that corresponds to a physical instance ID of a
	// resource supported by AWS CloudFormation.
	PhysicalResourceId *string

	// Current status of the resource.
	//
	// This member is required.
	ResourceStatus ResourceStatus

	// Type of resource. (For more information, go to  AWS Resource Types Reference
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
	// in the AWS CloudFormation User Guide.)
	//
	// This member is required.
	ResourceType *string

	// Time the status was updated.
	//
	// This member is required.
	Timestamp *time.Time

	// The name associated with the stack.
	StackName *string

	// Unique identifier of the stack.
	StackId *string
}

type StackResourceDetail struct {

	// Information about whether the resource's actual configuration differs, or has
	// drifted, from its expected configuration, as defined in the stack template and
	// any values specified as template parameters. For more information, see Detecting
	// Unregulated Configuration Changes to Stacks and Resources
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).
	DriftInformation *StackResourceDriftInformation

	// Unique identifier of the stack.
	StackId *string

	// The name associated with the stack.
	StackName *string

	// The logical name of the resource specified in the template.
	//
	// This member is required.
	LogicalResourceId *string

	// Time the status was updated.
	//
	// This member is required.
	LastUpdatedTimestamp *time.Time

	// The name or unique identifier that corresponds to a physical instance ID of a
	// resource supported by AWS CloudFormation.
	PhysicalResourceId *string

	// The content of the Metadata attribute declared for the resource. For more
	// information, see Metadata Attribute
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-metadata.html)
	// in the AWS CloudFormation User Guide.
	Metadata *string

	// User defined description associated with the resource.
	Description *string

	// Type of resource. ((For more information, go to  AWS Resource Types Reference
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
	// in the AWS CloudFormation User Guide.)
	//
	// This member is required.
	ResourceType *string

	// Success/failure message associated with the resource.
	ResourceStatusReason *string

	// Current status of the resource.
	//
	// This member is required.
	ResourceStatus ResourceStatus
}

type StackResourceDrift struct {

	// The logical name of the resource specified in the template.
	//
	// This member is required.
	LogicalResourceId *string

	// Context information that enables AWS CloudFormation to uniquely identify a
	// resource. AWS CloudFormation uses context key-value pairs in cases where a
	// resource's logical and physical IDs are not enough to uniquely identify that
	// resource. Each context key-value pair specifies a unique resource that contains
	// the targeted resource.
	PhysicalResourceIdContext []*PhysicalResourceIdContextKeyValuePair

	// A JSON structure containing the actual property values of the stack resource.
	// For resources whose StackResourceDriftStatus is DELETED, this structure will not
	// be present.
	ActualProperties *string

	// Status of the resource's actual configuration compared to its expected
	// configuration
	//
	//     * DELETED: The resource differs from its expected template
	// configuration because the resource has been deleted.
	//
	//     * MODIFIED: One or
	// more resource properties differ from their expected values (as defined in the
	// stack template and any values specified as template parameters).
	//
	//     * IN_SYNC:
	// The resources's actual configuration matches its expected template
	// configuration.
	//
	//     * NOT_CHECKED: AWS CloudFormation does not currently return
	// this value.
	//
	// This member is required.
	StackResourceDriftStatus StackResourceDriftStatus

	// The type of the resource.
	//
	// This member is required.
	ResourceType *string

	// The name or unique identifier that corresponds to a physical instance ID of a
	// resource supported by AWS CloudFormation.
	PhysicalResourceId *string

	// Time at which AWS CloudFormation performed drift detection on the stack
	// resource.
	//
	// This member is required.
	Timestamp *time.Time

	// A JSON structure containing the expected property values of the stack resource,
	// as defined in the stack template and any values specified as template
	// parameters. For resources whose StackResourceDriftStatus is DELETED, this
	// structure will not be present.
	ExpectedProperties *string

	// The ID of the stack.
	//
	// This member is required.
	StackId *string

	// A collection of the resource properties whose actual values differ from their
	// expected values. These will be present only for resources whose
	// StackResourceDriftStatus is MODIFIED.
	PropertyDifferences []*PropertyDifference
}

type StackResourceDriftInformation struct {

	// Status of the resource's actual configuration compared to its expected
	// configuration
	//
	//     * DELETED: The resource differs from its expected
	// configuration in that it has been deleted.
	//
	//     * MODIFIED: The resource differs
	// from its expected configuration.
	//
	//     * NOT_CHECKED: AWS CloudFormation has not
	// checked if the resource differs from its expected configuration. Any resources
	// that do not currently support drift detection have a status of NOT_CHECKED. For
	// more information, see Resources that Support Drift Detection
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html).
	//
	//
	// * IN_SYNC: The resources's actual configuration matches its expected
	// configuration.
	//
	// This member is required.
	StackResourceDriftStatus StackResourceDriftStatus

	// When AWS CloudFormation last checked if the resource had drifted from its
	// expected configuration.
	LastCheckTimestamp *time.Time
}

type StackResourceDriftInformationSummary struct {

	// When AWS CloudFormation last checked if the resource had drifted from its
	// expected configuration.
	LastCheckTimestamp *time.Time

	// Status of the resource's actual configuration compared to its expected
	// configuration
	//
	//     * DELETED: The resource differs from its expected
	// configuration in that it has been deleted.
	//
	//     * MODIFIED: The resource differs
	// from its expected configuration.
	//
	//     * NOT_CHECKED: AWS CloudFormation has not
	// checked if the resource differs from its expected configuration. Any resources
	// that do not currently support drift detection have a status of NOT_CHECKED. For
	// more information, see Resources that Support Drift Detection
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html).
	// If you performed an ContinueUpdateRollback () operation on a stack, any
	// resources included in ResourcesToSkip will also have a status of NOT_CHECKED.
	// For more information on skipping resources during rollback operations, see
	// Continue Rolling Back an Update
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html)
	// in the AWS CloudFormation User Guide.
	//
	//     * IN_SYNC: The resources's actual
	// configuration matches its expected configuration.
	//
	// This member is required.
	StackResourceDriftStatus StackResourceDriftStatus
}

type StackResourceDriftStatus string

const (
	StackResourceDriftStatusIn_sync     StackResourceDriftStatus = "IN_SYNC"
	StackResourceDriftStatusModified    StackResourceDriftStatus = "MODIFIED"
	StackResourceDriftStatusDeleted     StackResourceDriftStatus = "DELETED"
	StackResourceDriftStatusNot_checked StackResourceDriftStatus = "NOT_CHECKED"
)

type StackResourceSummary struct {

	// Success/failure message associated with the resource.
	ResourceStatusReason *string

	// The logical name of the resource specified in the template.
	//
	// This member is required.
	LogicalResourceId *string

	// The name or unique identifier that corresponds to a physical instance ID of the
	// resource.
	PhysicalResourceId *string

	// Time the status was updated.
	//
	// This member is required.
	LastUpdatedTimestamp *time.Time

	// Type of resource. (For more information, go to  AWS Resource Types Reference
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html)
	// in the AWS CloudFormation User Guide.)
	//
	// This member is required.
	ResourceType *string

	// Information about whether the resource's actual configuration differs, or has
	// drifted, from its expected configuration, as defined in the stack template and
	// any values specified as template parameters. For more information, see Detecting
	// Unregulated Configuration Changes to Stacks and Resources
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).
	DriftInformation *StackResourceDriftInformationSummary

	// Current status of the resource.
	//
	// This member is required.
	ResourceStatus ResourceStatus
}

type StackSet struct {

	// The status of the stack set.
	Status StackSetStatus

	// The name that's associated with the stack set.
	StackSetName *string

	// The name of the IAM execution role used to create or update the stack set. Use
	// customized execution roles to control which stack resources users and groups can
	// include in their stack sets.
	ExecutionRoleName *string

	// A description of the stack set that you specify when the stack set is created or
	// updated.
	Description *string

	// The Amazon Resource Number (ARN) of the IAM role used to create or update the
	// stack set. Use customized administrator roles to control which users or groups
	// can manage specific stack sets within the same administrator account. For more
	// information, see Prerequisites: Granting Permissions for Stack Set Operations
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html)
	// in the AWS CloudFormation User Guide.
	AdministrationRoleARN *string

	// [Service-managed permissions] The organization root ID or organizational unit
	// (OU) IDs that you specified for DeploymentTargets
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeploymentTargets.html).
	OrganizationalUnitIds []*string

	// A list of tags that specify information about the stack set. A maximum number of
	// 50 tags can be specified.
	Tags []*Tag

	// Detailed information about the drift status of the stack set. For stack sets,
	// contains information about the last completed drift operation performed on the
	// stack set. Information about drift operations currently in progress is not
	// included.
	StackSetDriftDetectionDetails *StackSetDriftDetectionDetails

	// Describes how the IAM roles required for stack set operations are created.
	//
	//
	// * With self-managed permissions, you must create the administrator and execution
	// roles required to deploy to target accounts. For more information, see Grant
	// Self-Managed Stack Set Permissions
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html).
	//
	//
	// * With service-managed permissions, StackSets automatically creates the IAM
	// roles required to deploy to accounts managed by AWS Organizations. For more
	// information, see Grant Service-Managed Stack Set Permissions
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-service-managed.html).
	PermissionModel PermissionModels

	// [Service-managed permissions] Describes whether StackSets automatically deploys
	// to AWS Organizations accounts that are added to a target organization or
	// organizational unit (OU).
	AutoDeployment *AutoDeployment

	// The ID of the stack set.
	StackSetId *string

	// The capabilities that are allowed in the stack set. Some stack set templates
	// might include resources that can affect permissions in your AWS account—for
	// example, by creating new AWS Identity and Access Management (IAM) users. For
	// more information, see Acknowledging IAM Resources in AWS CloudFormation
	// Templates.
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities)
	Capabilities []Capability

	// The Amazon Resource Number (ARN) of the stack set.
	StackSetARN *string

	// A list of input parameters for a stack set.
	Parameters []*Parameter

	// The structure that contains the body of the template that was used to create or
	// update the stack set.
	TemplateBody *string
}

type StackSetDriftDetectionDetails struct {

	// The total number of stack instances belonging to this stack set. The total
	// number of stack instances is equal to the total of:
	//
	//     * Stack instances that
	// match the stack set configuration.
	//
	//     * Stack instances that have drifted from
	// the stack set configuration.
	//
	//     * Stack instances where the drift detection
	// operation has failed.
	//
	//     * Stack instances currently being checked for drift.
	TotalStackInstancesCount *int32

	// The number of stack instances that have drifted from the expected template and
	// parameter configuration of the stack set. A stack instance is considered to have
	// drifted if one or more of the resources in the associated stack do not match
	// their expected configuration.
	DriftedStackInstancesCount *int32

	// The number of stack instances which match the expected template and parameter
	// configuration of the stack set.
	InSyncStackInstancesCount *int32

	// The status of the stack set drift detection operation.
	//
	//     * COMPLETED: The
	// drift detection operation completed without failing on any stack instances.
	//
	//
	// * FAILED: The drift detection operation exceeded the specified failure
	// tolerance.
	//
	//     * PARTIAL_SUCCESS: The drift detection operation completed
	// without exceeding the failure tolerance for the operation.
	//
	//     * IN_PROGRESS:
	// The drift detection operation is currently being performed.
	//
	//     * STOPPED: The
	// user has cancelled the drift detection operation.
	DriftDetectionStatus StackSetDriftDetectionStatus

	// Status of the stack set's actual configuration compared to its expected template
	// and parameter configuration. A stack set is considered to have drifted if one or
	// more of its stack instances have drifted from their expected template and
	// parameter configuration.
	//
	//     * DRIFTED: One or more of the stack instances
	// belonging to the stack set stack differs from the expected template and
	// parameter configuration. A stack instance is considered to have drifted if one
	// or more of the resources in the associated stack have drifted.
	//
	//     *
	// NOT_CHECKED: AWS CloudFormation has not checked the stack set for drift.
	//
	//     *
	// IN_SYNC: All of the stack instances belonging to the stack set stack match from
	// the expected template and parameter configuration.
	DriftStatus StackSetDriftStatus

	// The number of stack instances that are currently being checked for drift.
	InProgressStackInstancesCount *int32

	// The number of stack instances for which the drift detection operation failed.
	FailedStackInstancesCount *int32

	// Most recent time when CloudFormation performed a drift detection operation on
	// the stack set. This value will be NULL for any stack set on which drift
	// detection has not yet been performed.
	LastDriftCheckTimestamp *time.Time
}

type StackSetDriftDetectionStatus string

const (
	StackSetDriftDetectionStatusCompleted       StackSetDriftDetectionStatus = "COMPLETED"
	StackSetDriftDetectionStatusFailed          StackSetDriftDetectionStatus = "FAILED"
	StackSetDriftDetectionStatusPartial_success StackSetDriftDetectionStatus = "PARTIAL_SUCCESS"
	StackSetDriftDetectionStatusIn_progress     StackSetDriftDetectionStatus = "IN_PROGRESS"
	StackSetDriftDetectionStatusStopped         StackSetDriftDetectionStatus = "STOPPED"
)

type StackSetDriftStatus string

const (
	StackSetDriftStatusDrifted     StackSetDriftStatus = "DRIFTED"
	StackSetDriftStatusIn_sync     StackSetDriftStatus = "IN_SYNC"
	StackSetDriftStatusNot_checked StackSetDriftStatus = "NOT_CHECKED"
)

type StackSetNotEmptyException struct {
	Message *string
}

type StackSetNotFoundException struct {
	Message *string
}

type StackSetOperation struct {

	// The ID of the stack set.
	StackSetId *string

	// The status of the operation.
	//
	//     * FAILED: The operation exceeded the specified
	// failure tolerance. The failure tolerance value that you've set for an operation
	// is applied for each Region during stack create and update operations. If the
	// number of failed stacks within a Region exceeds the failure tolerance, the
	// status of the operation in the Region is set to FAILED. This in turn sets the
	// status of the operation as a whole to FAILED, and AWS CloudFormation cancels the
	// operation in any remaining Regions.
	//
	//     * QUEUED: [Service-managed permissions]
	// For automatic deployments that require a sequence of operations, the operation
	// is queued to be performed. For more information, see the stack set operation
	// status codes
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-status-codes)
	// in the AWS CloudFormation User Guide.
	//
	//     * RUNNING: The operation is currently
	// being performed.
	//
	//     * STOPPED: The user has cancelled the operation.
	//
	//     *
	// STOPPING: The operation is in the process of stopping, at user request.
	//
	//     *
	// SUCCEEDED: The operation completed creating or updating all the specified stacks
	// without exceeding the failure tolerance for the operation.
	Status StackSetOperationStatus

	// For stack set operations of action type DELETE, specifies whether to remove the
	// stack instances from the specified stack set, but doesn't delete the stacks. You
	// can't reassociate a retained stack, or add an existing, saved stack to a new
	// stack set.
	RetainStacks *bool

	// The preferences for how AWS CloudFormation performs this stack set operation.
	OperationPreferences *StackSetOperationPreferences

	// The time at which the stack set operation ended, across all accounts and Regions
	// specified. Note that this doesn't necessarily mean that the stack set operation
	// was successful, or even attempted, in each account or Region.
	EndTimestamp *time.Time

	// [Service-managed permissions] The AWS Organizations accounts affected by the
	// stack operation.
	DeploymentTargets *DeploymentTargets

	// The name of the IAM execution role used to create or update the stack set. Use
	// customized execution roles to control which stack resources users and groups can
	// include in their stack sets.
	ExecutionRoleName *string

	// The unique ID of a stack set operation.
	OperationId *string

	// Detailed information about the drift status of the stack set. This includes
	// information about drift operations currently being performed on the stack set.
	// this information will only be present for stack set operations whose Action type
	// is DETECT_DRIFT. For more information, see Detecting Unmanaged Changes in Stack
	// Sets
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-drift.html)
	// in the AWS CloudFormation User Guide.
	StackSetDriftDetectionDetails *StackSetDriftDetectionDetails

	// The type of stack set operation: CREATE, UPDATE, or DELETE. Create and delete
	// operations affect only the specified stack set instances that are associated
	// with the specified stack set. Update operations affect both the stack set
	// itself, as well as all associated stack set instances.
	Action StackSetOperationAction

	// The time at which the operation was initiated. Note that the creation times for
	// the stack set operation might differ from the creation time of the individual
	// stacks themselves. This is because AWS CloudFormation needs to perform
	// preparatory work for the operation, such as dispatching the work to the
	// requested Regions, before actually creating the first stacks.
	CreationTimestamp *time.Time

	// The Amazon Resource Number (ARN) of the IAM role used to perform this stack set
	// operation. Use customized administrator roles to control which users or groups
	// can manage specific stack sets within the same administrator account. For more
	// information, see Define Permissions for Multiple Administrators
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html)
	// in the AWS CloudFormation User Guide.
	AdministrationRoleARN *string
}

type StackSetOperationAction string

const (
	StackSetOperationActionCreate       StackSetOperationAction = "CREATE"
	StackSetOperationActionUpdate       StackSetOperationAction = "UPDATE"
	StackSetOperationActionDelete       StackSetOperationAction = "DELETE"
	StackSetOperationActionDetect_drift StackSetOperationAction = "DETECT_DRIFT"
)

type StackSetOperationPreferences struct {

	// The maximum number of accounts in which to perform this operation at one time.
	// This is dependent on the value of FailureToleranceCount. MaxConcurrentCount is
	// at most one more than the FailureToleranceCount. Note that this setting lets you
	// specify the maximum for operations. For large deployments, under certain
	// circumstances the actual number of accounts acted upon concurrently may be lower
	// due to service throttling. Conditional: You must specify either
	// MaxConcurrentCount or MaxConcurrentPercentage, but not both.
	MaxConcurrentCount *int32

	// The order of the Regions in where you want to perform the stack operation.
	RegionOrder []*string

	// The number of accounts, per Region, for which this operation can fail before AWS
	// CloudFormation stops the operation in that Region. If the operation is stopped
	// in a Region, AWS CloudFormation doesn't attempt the operation in any subsequent
	// Regions. Conditional: You must specify either FailureToleranceCount or
	// FailureTolerancePercentage (but not both).
	FailureToleranceCount *int32

	// The percentage of accounts, per Region, for which this stack operation can fail
	// before AWS CloudFormation stops the operation in that Region. If the operation
	// is stopped in a Region, AWS CloudFormation doesn't attempt the operation in any
	// subsequent Regions. When calculating the number of accounts based on the
	// specified percentage, AWS CloudFormation rounds down to the next whole number.
	// Conditional: You must specify either FailureToleranceCount or
	// FailureTolerancePercentage, but not both.
	FailureTolerancePercentage *int32

	// The maximum percentage of accounts in which to perform this operation at one
	// time. When calculating the number of accounts based on the specified percentage,
	// AWS CloudFormation rounds down to the next whole number. This is true except in
	// cases where rounding down would result is zero. In this case, CloudFormation
	// sets the number as one instead. Note that this setting lets you specify the
	// maximum for operations. For large deployments, under certain circumstances the
	// actual number of accounts acted upon concurrently may be lower due to service
	// throttling. Conditional: You must specify either MaxConcurrentCount or
	// MaxConcurrentPercentage, but not both.
	MaxConcurrentPercentage *int32
}

type StackSetOperationResultStatus string

const (
	StackSetOperationResultStatusPending   StackSetOperationResultStatus = "PENDING"
	StackSetOperationResultStatusRunning   StackSetOperationResultStatus = "RUNNING"
	StackSetOperationResultStatusSucceeded StackSetOperationResultStatus = "SUCCEEDED"
	StackSetOperationResultStatusFailed    StackSetOperationResultStatus = "FAILED"
	StackSetOperationResultStatusCancelled StackSetOperationResultStatus = "CANCELLED"
)

type StackSetOperationResultSummary struct {

	// The results of the account gate function AWS CloudFormation invokes, if present,
	// before proceeding with stack set operations in an account
	AccountGateResult *AccountGateResult

	// The reason for the assigned result status.
	StatusReason *string

	// The name of the AWS Region for this operation result.
	Region *string

	// The result status of the stack set operation for the given account in the given
	// Region.
	//
	//     * CANCELLED: The operation in the specified account and Region has
	// been cancelled. This is either because a user has stopped the stack set
	// operation, or because the failure tolerance of the stack set operation has been
	// exceeded.
	//
	//     * FAILED: The operation in the specified account and Region
	// failed. If the stack set operation fails in enough accounts within a Region, the
	// failure tolerance for the stack set operation as a whole might be exceeded.
	//
	//
	// * RUNNING: The operation in the specified account and Region is currently in
	// progress.
	//
	//     * PENDING: The operation in the specified account and Region has
	// yet to start.
	//
	//     * SUCCEEDED: The operation in the specified account and
	// Region completed successfully.
	Status StackSetOperationResultStatus

	// [Self-managed permissions] The name of the AWS account for this operation
	// result.
	Account *string

	// [Service-managed permissions] The organization root ID or organizational unit
	// (OU) IDs that you specified for DeploymentTargets
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeploymentTargets.html).
	OrganizationalUnitId *string
}

type StackSetOperationStatus string

const (
	StackSetOperationStatusRunning   StackSetOperationStatus = "RUNNING"
	StackSetOperationStatusSucceeded StackSetOperationStatus = "SUCCEEDED"
	StackSetOperationStatusFailed    StackSetOperationStatus = "FAILED"
	StackSetOperationStatusStopping  StackSetOperationStatus = "STOPPING"
	StackSetOperationStatusStopped   StackSetOperationStatus = "STOPPED"
	StackSetOperationStatusQueued    StackSetOperationStatus = "QUEUED"
)

type StackSetOperationSummary struct {

	// The type of operation: CREATE, UPDATE, or DELETE. Create and delete operations
	// affect only the specified stack instances that are associated with the specified
	// stack set. Update operations affect both the stack set itself as well as all
	// associated stack set instances.
	Action StackSetOperationAction

	// The overall status of the operation.
	//
	//     * FAILED: The operation exceeded the
	// specified failure tolerance. The failure tolerance value that you've set for an
	// operation is applied for each Region during stack create and update operations.
	// If the number of failed stacks within a Region exceeds the failure tolerance,
	// the status of the operation in the Region is set to FAILED. This in turn sets
	// the status of the operation as a whole to FAILED, and AWS CloudFormation cancels
	// the operation in any remaining Regions.
	//
	//     * QUEUED: [Service-managed
	// permissions] For automatic deployments that require a sequence of operations,
	// the operation is queued to be performed. For more information, see the stack set
	// operation status codes
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-status-codes)
	// in the AWS CloudFormation User Guide.
	//
	//     * RUNNING: The operation is currently
	// being performed.
	//
	//     * STOPPED: The user has cancelled the operation.
	//
	//     *
	// STOPPING: The operation is in the process of stopping, at user request.
	//
	//     *
	// SUCCEEDED: The operation completed creating or updating all the specified stacks
	// without exceeding the failure tolerance for the operation.
	Status StackSetOperationStatus

	// The unique ID of the stack set operation.
	OperationId *string

	// The time at which the operation was initiated. Note that the creation times for
	// the stack set operation might differ from the creation time of the individual
	// stacks themselves. This is because AWS CloudFormation needs to perform
	// preparatory work for the operation, such as dispatching the work to the
	// requested Regions, before actually creating the first stacks.
	CreationTimestamp *time.Time

	// The time at which the stack set operation ended, across all accounts and Regions
	// specified. Note that this doesn't necessarily mean that the stack set operation
	// was successful, or even attempted, in each account or Region.
	EndTimestamp *time.Time
}

type StackSetStatus string

const (
	StackSetStatusActive  StackSetStatus = "ACTIVE"
	StackSetStatusDeleted StackSetStatus = "DELETED"
)

type StackSetSummary struct {

	// The status of the stack set.
	Status StackSetStatus

	// [Service-managed permissions] Describes whether StackSets automatically deploys
	// to AWS Organizations accounts that are added to a target organizational unit
	// (OU).
	AutoDeployment *AutoDeployment

	// A description of the stack set that you specify when the stack set is created or
	// updated.
	Description *string

	// The ID of the stack set.
	StackSetId *string

	// Describes how the IAM roles required for stack set operations are created.
	//
	//
	// * With self-managed permissions, you must create the administrator and execution
	// roles required to deploy to target accounts. For more information, see Grant
	// Self-Managed Stack Set Permissions
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html).
	//
	//
	// * With service-managed permissions, StackSets automatically creates the IAM
	// roles required to deploy to accounts managed by AWS Organizations. For more
	// information, see Grant Service-Managed Stack Set Permissions
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-service-managed.html).
	PermissionModel PermissionModels

	// Most recent time when CloudFormation performed a drift detection operation on
	// the stack set. This value will be NULL for any stack set on which drift
	// detection has not yet been performed.
	LastDriftCheckTimestamp *time.Time

	// The name of the stack set.
	StackSetName *string

	// Status of the stack set's actual configuration compared to its expected template
	// and parameter configuration. A stack set is considered to have drifted if one or
	// more of its stack instances have drifted from their expected template and
	// parameter configuration.
	//
	//     * DRIFTED: One or more of the stack instances
	// belonging to the stack set stack differs from the expected template and
	// parameter configuration. A stack instance is considered to have drifted if one
	// or more of the resources in the associated stack have drifted.
	//
	//     *
	// NOT_CHECKED: AWS CloudFormation has not checked the stack set for drift.
	//
	//     *
	// IN_SYNC: All of the stack instances belonging to the stack set stack match from
	// the expected template and parameter configuration.
	//
	//     * UNKNOWN: This value is
	// reserved for future use.
	DriftStatus StackDriftStatus
}

type StackStatus string

const (
	StackStatusCreate_in_progress                           StackStatus = "CREATE_IN_PROGRESS"
	StackStatusCreate_failed                                StackStatus = "CREATE_FAILED"
	StackStatusCreate_complete                              StackStatus = "CREATE_COMPLETE"
	StackStatusRollback_in_progress                         StackStatus = "ROLLBACK_IN_PROGRESS"
	StackStatusRollback_failed                              StackStatus = "ROLLBACK_FAILED"
	StackStatusRollback_complete                            StackStatus = "ROLLBACK_COMPLETE"
	StackStatusDelete_in_progress                           StackStatus = "DELETE_IN_PROGRESS"
	StackStatusDelete_failed                                StackStatus = "DELETE_FAILED"
	StackStatusDelete_complete                              StackStatus = "DELETE_COMPLETE"
	StackStatusUpdate_in_progress                           StackStatus = "UPDATE_IN_PROGRESS"
	StackStatusUpdate_complete_cleanup_in_progress          StackStatus = "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"
	StackStatusUpdate_complete                              StackStatus = "UPDATE_COMPLETE"
	StackStatusUpdate_rollback_in_progress                  StackStatus = "UPDATE_ROLLBACK_IN_PROGRESS"
	StackStatusUpdate_rollback_failed                       StackStatus = "UPDATE_ROLLBACK_FAILED"
	StackStatusUpdate_rollback_complete_cleanup_in_progress StackStatus = "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"
	StackStatusUpdate_rollback_complete                     StackStatus = "UPDATE_ROLLBACK_COMPLETE"
	StackStatusReview_in_progress                           StackStatus = "REVIEW_IN_PROGRESS"
	StackStatusImport_in_progress                           StackStatus = "IMPORT_IN_PROGRESS"
	StackStatusImport_complete                              StackStatus = "IMPORT_COMPLETE"
	StackStatusImport_rollback_in_progress                  StackStatus = "IMPORT_ROLLBACK_IN_PROGRESS"
	StackStatusImport_rollback_failed                       StackStatus = "IMPORT_ROLLBACK_FAILED"
	StackStatusImport_rollback_complete                     StackStatus = "IMPORT_ROLLBACK_COMPLETE"
)

type StackSummary struct {

	// Success/Failure message associated with the stack status.
	StackStatusReason *string

	// The name associated with the stack.
	//
	// This member is required.
	StackName *string

	// Unique stack identifier.
	StackId *string

	// The time the stack was last updated. This field will only be returned if the
	// stack has been updated at least once.
	LastUpdatedTime *time.Time

	// Summarizes information on whether a stack's actual configuration differs, or has
	// drifted, from it's expected configuration, as defined in the stack template and
	// any values specified as template parameters. For more information, see Detecting
	// Unregulated Configuration Changes to Stacks and Resources
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).
	DriftInformation *StackDriftInformationSummary

	// The time the stack was created.
	//
	// This member is required.
	CreationTime *time.Time

	// For nested stacks--stacks created as resources for another stack--the stack ID
	// of the direct parent of this stack. For the first level of nested stacks, the
	// root stack is also the parent stack. For more information, see Working with
	// Nested Stacks
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
	// in the AWS CloudFormation User Guide.
	ParentId *string

	// For nested stacks--stacks created as resources for another stack--the stack ID
	// of the top-level stack to which the nested stack ultimately belongs. For more
	// information, see Working with Nested Stacks
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html)
	// in the AWS CloudFormation User Guide.
	RootId *string

	// The current status of the stack.
	//
	// This member is required.
	StackStatus StackStatus

	// The time the stack was deleted.
	DeletionTime *time.Time

	// The template description of the template used to create the stack.
	TemplateDescription *string
}

type StaleRequestException struct {
	Message *string
}

type Tag struct {

	// Required. A string containing the value for this tag. You can specify a maximum
	// of 256 characters for a tag value.
	//
	// This member is required.
	Value *string

	// Required. A string used to identify this tag. You can specify a maximum of 128
	// characters for a tag key. Tags owned by Amazon Web Services (AWS) have the
	// reserved prefix: aws:.
	//
	// This member is required.
	Key *string
}

type TemplateParameter struct {

	// User defined description associated with the parameter.
	Description *string

	// The name associated with the parameter.
	ParameterKey *string

	// Flag indicating whether the parameter should be displayed as plain text in logs
	// and UIs.
	NoEcho *bool

	// The default value associated with the parameter.
	DefaultValue *string
}

type TemplateStage string

const (
	TemplateStageOriginal  TemplateStage = "Original"
	TemplateStageProcessed TemplateStage = "Processed"
)

type TokenAlreadyExistsException struct {
	Message *string
}

type TypeNotFoundException struct {
	Message *string
}

type TypeSummary struct {

	// The kind of type.
	Type RegistryType

	// The name of the type.
	TypeName *string

	// The description of the type.
	Description *string

	// The ID of the default version of the type. The default version is used when the
	// type version is not specified. To set the default version of a type, use
	// SetTypeDefaultVersion ().
	DefaultVersionId *string

	// When the current default version of the type was registered.
	LastUpdated *time.Time

	// The Amazon Resource Name (ARN) of the type.
	TypeArn *string
}

type TypeVersionSummary struct {

	// The Amazon Resource Name (ARN) of the type version.
	Arn *string

	// The name of the type.
	TypeName *string

	// The description of the type version.
	Description *string

	// The ID of a specific version of the type. The version ID is the value at the end
	// of the Amazon Resource Name (ARN) assigned to the type version when it is
	// registered.
	VersionId *string

	// When the version was registered.
	TimeCreated *time.Time

	// Whether the specified type version is set as the default version.
	IsDefaultVersion *bool

	// The kind of type.
	Type RegistryType
}

type Visibility string

const (
	VisibilityPublic  Visibility = "PUBLIC"
	VisibilityPrivate Visibility = "PRIVATE"
)