Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountGateResult

type AccountGateResult struct {

	// 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

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

    Structure that contains the results of the account gate function which AWS CloudFormation invokes, if present, before proceeding with a stack set operation in an account and Region. For each account and Region, AWS CloudFormation lets you specify a Lamdba function that encapsulates any requirements that must be met before CloudFormation can proceed with a stack set operation in that account and Region. CloudFormation invokes the function each time a stack set operation is requested for that account and Region; if the function returns FAILED, CloudFormation cancels the operation in that account and Region, and sets the stack set operation result status for that account and Region to FAILED. For more information, see Configuring a target account gate (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-account-gating.html).

    type AccountGateStatus

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

      Enum values for AccountGateStatus

      func (AccountGateStatus) Values

        Values returns all known values for AccountGateStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type AccountLimit

        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
        }

          The AccountLimit data type. CloudFormation has the following limits per account:

          * Number of concurrent resources

          * Number of stacks

          * Number of stack outputs

          For more information about these account limits, and other CloudFormation limits, see AWS CloudFormation Limits (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html) in the AWS CloudFormation User Guide.

          type AlreadyExistsException

          type AlreadyExistsException struct {
          	Message *string
          }

            The resource with the name requested already exists.

            func (*AlreadyExistsException) Error

            func (e *AlreadyExistsException) Error() string

            func (*AlreadyExistsException) ErrorCode

            func (e *AlreadyExistsException) ErrorCode() string

            func (*AlreadyExistsException) ErrorFault

            func (e *AlreadyExistsException) ErrorFault() smithy.ErrorFault

            func (*AlreadyExistsException) ErrorMessage

            func (e *AlreadyExistsException) ErrorMessage() string

            type AutoDeployment

            type AutoDeployment struct {
            
            	// 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
            
            	// 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
            }

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

              type CFNRegistryException

              type CFNRegistryException struct {
              	Message *string
              }

                An error occurred during a CloudFormation registry operation.

                func (*CFNRegistryException) Error

                func (e *CFNRegistryException) Error() string

                func (*CFNRegistryException) ErrorCode

                func (e *CFNRegistryException) ErrorCode() string

                func (*CFNRegistryException) ErrorFault

                func (e *CFNRegistryException) ErrorFault() smithy.ErrorFault

                func (*CFNRegistryException) ErrorMessage

                func (e *CFNRegistryException) ErrorMessage() string

                type CallAs

                type CallAs string
                const (
                	CallAsSelf           CallAs = "SELF"
                	CallAsDelegatedAdmin CallAs = "DELEGATED_ADMIN"
                )

                  Enum values for CallAs

                  func (CallAs) Values

                  func (CallAs) Values() []CallAs

                    Values returns all known values for CallAs. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type Capability

                    type Capability string
                    const (
                    	CapabilityCapabilityIam        Capability = "CAPABILITY_IAM"
                    	CapabilityCapabilityNamedIam   Capability = "CAPABILITY_NAMED_IAM"
                    	CapabilityCapabilityAutoExpand Capability = "CAPABILITY_AUTO_EXPAND"
                    )

                      Enum values for Capability

                      func (Capability) Values

                      func (Capability) Values() []Capability

                        Values returns all known values for Capability. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                        type Change

                        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
                        }

                          The Change structure describes the changes AWS CloudFormation will perform if you execute the change set.

                          type ChangeAction

                          type ChangeAction string
                          const (
                          	ChangeActionAdd     ChangeAction = "Add"
                          	ChangeActionModify  ChangeAction = "Modify"
                          	ChangeActionRemove  ChangeAction = "Remove"
                          	ChangeActionImport  ChangeAction = "Import"
                          	ChangeActionDynamic ChangeAction = "Dynamic"
                          )

                            Enum values for ChangeAction

                            func (ChangeAction) Values

                            func (ChangeAction) Values() []ChangeAction

                              Values returns all known values for ChangeAction. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                              type ChangeSetNotFoundException

                              type ChangeSetNotFoundException struct {
                              	Message *string
                              }

                                The specified change set name or ID doesn't exit. To view valid change sets for a stack, use the ListChangeSets action.

                                func (*ChangeSetNotFoundException) Error

                                func (*ChangeSetNotFoundException) ErrorCode

                                func (e *ChangeSetNotFoundException) ErrorCode() string

                                func (*ChangeSetNotFoundException) ErrorFault

                                func (*ChangeSetNotFoundException) ErrorMessage

                                func (e *ChangeSetNotFoundException) ErrorMessage() string

                                type ChangeSetStatus

                                type ChangeSetStatus string
                                const (
                                	ChangeSetStatusCreatePending    ChangeSetStatus = "CREATE_PENDING"
                                	ChangeSetStatusCreateInProgress ChangeSetStatus = "CREATE_IN_PROGRESS"
                                	ChangeSetStatusCreateComplete   ChangeSetStatus = "CREATE_COMPLETE"
                                	ChangeSetStatusDeletePending    ChangeSetStatus = "DELETE_PENDING"
                                	ChangeSetStatusDeleteInProgress ChangeSetStatus = "DELETE_IN_PROGRESS"
                                	ChangeSetStatusDeleteComplete   ChangeSetStatus = "DELETE_COMPLETE"
                                	ChangeSetStatusDeleteFailed     ChangeSetStatus = "DELETE_FAILED"
                                	ChangeSetStatusFailed           ChangeSetStatus = "FAILED"
                                )

                                  Enum values for ChangeSetStatus

                                  func (ChangeSetStatus) Values

                                  func (ChangeSetStatus) Values() []ChangeSetStatus

                                    Values returns all known values for ChangeSetStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                    type ChangeSetSummary

                                    type ChangeSetSummary struct {
                                    
                                    	// The ID of the change set.
                                    	ChangeSetId *string
                                    
                                    	// The name of the change set.
                                    	ChangeSetName *string
                                    
                                    	// The start time when the change set was created, in UTC.
                                    	CreationTime *time.Time
                                    
                                    	// Descriptive information about the change set.
                                    	Description *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
                                    
                                    	// Specifies the current setting of IncludeNestedStacks for the change set.
                                    	IncludeNestedStacks *bool
                                    
                                    	// The parent change set ID.
                                    	ParentChangeSetId *string
                                    
                                    	// The root change set ID.
                                    	RootChangeSetId *string
                                    
                                    	// The ID of the stack with which the change set is associated.
                                    	StackId *string
                                    
                                    	// The name of the stack with which the change set is associated.
                                    	StackName *string
                                    
                                    	// 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
                                    }

                                      The ChangeSetSummary structure describes a change set, its status, and the stack with which it's associated.

                                      type ChangeSetType

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

                                        Enum values for ChangeSetType

                                        func (ChangeSetType) Values

                                        func (ChangeSetType) Values() []ChangeSetType

                                          Values returns all known values for ChangeSetType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                          type ChangeSource

                                          type ChangeSource string
                                          const (
                                          	ChangeSourceResourceReference  ChangeSource = "ResourceReference"
                                          	ChangeSourceParameterReference ChangeSource = "ParameterReference"
                                          	ChangeSourceResourceAttribute  ChangeSource = "ResourceAttribute"
                                          	ChangeSourceDirectModification ChangeSource = "DirectModification"
                                          	ChangeSourceAutomatic          ChangeSource = "Automatic"
                                          )

                                            Enum values for ChangeSource

                                            func (ChangeSource) Values

                                            func (ChangeSource) Values() []ChangeSource

                                              Values returns all known values for ChangeSource. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                              type ChangeType

                                              type ChangeType string
                                              const (
                                              	ChangeTypeResource ChangeType = "Resource"
                                              )

                                                Enum values for ChangeType

                                                func (ChangeType) Values

                                                func (ChangeType) Values() []ChangeType

                                                  Values returns all known values for ChangeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                  type CreatedButModifiedException

                                                  type CreatedButModifiedException struct {
                                                  	Message *string
                                                  }

                                                    The specified resource exists, but has been changed.

                                                    func (*CreatedButModifiedException) Error

                                                    func (*CreatedButModifiedException) ErrorCode

                                                    func (e *CreatedButModifiedException) ErrorCode() string

                                                    func (*CreatedButModifiedException) ErrorFault

                                                    func (*CreatedButModifiedException) ErrorMessage

                                                    func (e *CreatedButModifiedException) ErrorMessage() string

                                                    type DeploymentTargets

                                                    type DeploymentTargets struct {
                                                    
                                                    	// The names of one or more AWS accounts for which you want to deploy stack set
                                                    	// updates.
                                                    	Accounts []string
                                                    
                                                    	AccountsUrl *string
                                                    
                                                    	// The organization root ID or organizational unit (OU) IDs to which StackSets
                                                    	// deploys.
                                                    	OrganizationalUnitIds []string
                                                    }

                                                      [Service-managed permissions] The AWS Organizations accounts to which StackSets deploys. StackSets does not deploy stack instances to the organization management account, even if the organization management account is in your organization or in an OU in your organization. For update operations, you can specify either Accounts or OrganizationalUnitIds. For create and delete operations, specify OrganizationalUnitIds.

                                                      type DeprecatedStatus

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

                                                        Enum values for DeprecatedStatus

                                                        func (DeprecatedStatus) Values

                                                          Values returns all known values for DeprecatedStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type DifferenceType

                                                          type DifferenceType string
                                                          const (
                                                          	DifferenceTypeAdd      DifferenceType = "ADD"
                                                          	DifferenceTypeRemove   DifferenceType = "REMOVE"
                                                          	DifferenceTypeNotEqual DifferenceType = "NOT_EQUAL"
                                                          )

                                                            Enum values for DifferenceType

                                                            func (DifferenceType) Values

                                                            func (DifferenceType) Values() []DifferenceType

                                                              Values returns all known values for DifferenceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                              type EvaluationType

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

                                                                Enum values for EvaluationType

                                                                func (EvaluationType) Values

                                                                func (EvaluationType) Values() []EvaluationType

                                                                  Values returns all known values for EvaluationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                  type ExecutionStatus

                                                                  type ExecutionStatus string
                                                                  const (
                                                                  	ExecutionStatusUnavailable       ExecutionStatus = "UNAVAILABLE"
                                                                  	ExecutionStatusAvailable         ExecutionStatus = "AVAILABLE"
                                                                  	ExecutionStatusExecuteInProgress ExecutionStatus = "EXECUTE_IN_PROGRESS"
                                                                  	ExecutionStatusExecuteComplete   ExecutionStatus = "EXECUTE_COMPLETE"
                                                                  	ExecutionStatusExecuteFailed     ExecutionStatus = "EXECUTE_FAILED"
                                                                  	ExecutionStatusObsolete          ExecutionStatus = "OBSOLETE"
                                                                  )

                                                                    Enum values for ExecutionStatus

                                                                    func (ExecutionStatus) Values

                                                                    func (ExecutionStatus) Values() []ExecutionStatus

                                                                      Values returns all known values for ExecutionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type Export

                                                                      type Export struct {
                                                                      
                                                                      	// The stack that contains the exported output name and value.
                                                                      	ExportingStackId *string
                                                                      
                                                                      	// 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 Export structure describes the exported output values for a stack.

                                                                        type HandlerErrorCode

                                                                        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"
                                                                        )

                                                                          Enum values for HandlerErrorCode

                                                                          func (HandlerErrorCode) Values

                                                                            Values returns all known values for HandlerErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                            type InsufficientCapabilitiesException

                                                                            type InsufficientCapabilitiesException struct {
                                                                            	Message *string
                                                                            }

                                                                              The template contains resources with capabilities that weren't specified in the Capabilities parameter.

                                                                              func (*InsufficientCapabilitiesException) Error

                                                                              func (*InsufficientCapabilitiesException) ErrorCode

                                                                              func (*InsufficientCapabilitiesException) ErrorFault

                                                                              func (*InsufficientCapabilitiesException) ErrorMessage

                                                                              func (e *InsufficientCapabilitiesException) ErrorMessage() string

                                                                              type InvalidChangeSetStatusException

                                                                              type InvalidChangeSetStatusException struct {
                                                                              	Message *string
                                                                              }

                                                                                The specified change set can't be used to update the stack. For example, the change set status might be CREATE_IN_PROGRESS, or the stack status might be UPDATE_IN_PROGRESS.

                                                                                func (*InvalidChangeSetStatusException) Error

                                                                                func (*InvalidChangeSetStatusException) ErrorCode

                                                                                func (e *InvalidChangeSetStatusException) ErrorCode() string

                                                                                func (*InvalidChangeSetStatusException) ErrorFault

                                                                                func (*InvalidChangeSetStatusException) ErrorMessage

                                                                                func (e *InvalidChangeSetStatusException) ErrorMessage() string

                                                                                type InvalidOperationException

                                                                                type InvalidOperationException struct {
                                                                                	Message *string
                                                                                }

                                                                                  The specified operation isn't valid.

                                                                                  func (*InvalidOperationException) Error

                                                                                  func (e *InvalidOperationException) Error() string

                                                                                  func (*InvalidOperationException) ErrorCode

                                                                                  func (e *InvalidOperationException) ErrorCode() string

                                                                                  func (*InvalidOperationException) ErrorFault

                                                                                  func (*InvalidOperationException) ErrorMessage

                                                                                  func (e *InvalidOperationException) ErrorMessage() string

                                                                                  type InvalidStateTransitionException

                                                                                  type InvalidStateTransitionException struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    Error reserved for use by the CloudFormation CLI (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html). CloudFormation does not return this error to users.

                                                                                    func (*InvalidStateTransitionException) Error

                                                                                    func (*InvalidStateTransitionException) ErrorCode

                                                                                    func (e *InvalidStateTransitionException) ErrorCode() string

                                                                                    func (*InvalidStateTransitionException) ErrorFault

                                                                                    func (*InvalidStateTransitionException) ErrorMessage

                                                                                    func (e *InvalidStateTransitionException) ErrorMessage() string

                                                                                    type LimitExceededException

                                                                                    type LimitExceededException struct {
                                                                                    	Message *string
                                                                                    }

                                                                                      The quota for the resource has already been reached. For information on resource and stack limitations, see Limits (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html) in the AWS CloudFormation User Guide.

                                                                                      func (*LimitExceededException) Error

                                                                                      func (e *LimitExceededException) Error() string

                                                                                      func (*LimitExceededException) ErrorCode

                                                                                      func (e *LimitExceededException) ErrorCode() string

                                                                                      func (*LimitExceededException) ErrorFault

                                                                                      func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                      func (*LimitExceededException) ErrorMessage

                                                                                      func (e *LimitExceededException) ErrorMessage() string

                                                                                      type LoggingConfig

                                                                                      type LoggingConfig struct {
                                                                                      
                                                                                      	// The Amazon CloudWatch log group to which CloudFormation sends error logging
                                                                                      	// information when invoking the type's handlers.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	LogGroupName *string
                                                                                      
                                                                                      	// The ARN of the role that CloudFormation should assume when sending log entries
                                                                                      	// to CloudWatch logs.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	LogRoleArn *string
                                                                                      }

                                                                                        Contains logging configuration information for a type.

                                                                                        type ModuleInfo

                                                                                        type ModuleInfo struct {
                                                                                        
                                                                                        	// A concantenated list of the logical IDs of the module or modules containing the
                                                                                        	// resource. Modules are listed starting with the inner-most nested module, and
                                                                                        	// separated by /. In the following example, the resource was created from a
                                                                                        	// module, moduleA, that is nested inside a parent module, moduleB. moduleA/moduleB
                                                                                        	// For more information, see Referencing resources in a module in the
                                                                                        	// CloudFormation User Guide.
                                                                                        	LogicalIdHierarchy *string
                                                                                        
                                                                                        	// A concantenated list of the the module type or types containing the resource.
                                                                                        	// Module types are listed starting with the inner-most nested module, and
                                                                                        	// separated by /. In the following example, the resource was created from a module
                                                                                        	// of type AWS::First::Example::MODULE, that is nested inside a parent module of
                                                                                        	// type AWS::Second::Example::MODULE.
                                                                                        	// AWS::First::Example::MODULE/AWS::Second::Example::MODULE
                                                                                        	TypeHierarchy *string
                                                                                        }

                                                                                          Contains information about the module from which the resource was created, if the resource was created from a module included in the stack template. For more information on modules, see Using modules to encapsulate and reuse resource configurations in the CloudFormation User Guide.

                                                                                          type NameAlreadyExistsException

                                                                                          type NameAlreadyExistsException struct {
                                                                                          	Message *string
                                                                                          }

                                                                                            The specified name is already in use.

                                                                                            func (*NameAlreadyExistsException) Error

                                                                                            func (*NameAlreadyExistsException) ErrorCode

                                                                                            func (e *NameAlreadyExistsException) ErrorCode() string

                                                                                            func (*NameAlreadyExistsException) ErrorFault

                                                                                            func (*NameAlreadyExistsException) ErrorMessage

                                                                                            func (e *NameAlreadyExistsException) ErrorMessage() string

                                                                                            type OnFailure

                                                                                            type OnFailure string
                                                                                            const (
                                                                                            	OnFailureDoNothing OnFailure = "DO_NOTHING"
                                                                                            	OnFailureRollback  OnFailure = "ROLLBACK"
                                                                                            	OnFailureDelete    OnFailure = "DELETE"
                                                                                            )

                                                                                              Enum values for OnFailure

                                                                                              func (OnFailure) Values

                                                                                              func (OnFailure) Values() []OnFailure

                                                                                                Values returns all known values for OnFailure. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                type OperationIdAlreadyExistsException

                                                                                                type OperationIdAlreadyExistsException struct {
                                                                                                	Message *string
                                                                                                }

                                                                                                  The specified operation ID already exists.

                                                                                                  func (*OperationIdAlreadyExistsException) Error

                                                                                                  func (*OperationIdAlreadyExistsException) ErrorCode

                                                                                                  func (*OperationIdAlreadyExistsException) ErrorFault

                                                                                                  func (*OperationIdAlreadyExistsException) ErrorMessage

                                                                                                  func (e *OperationIdAlreadyExistsException) ErrorMessage() string

                                                                                                  type OperationInProgressException

                                                                                                  type OperationInProgressException struct {
                                                                                                  	Message *string
                                                                                                  }

                                                                                                    Another operation is currently in progress for this stack set. Only one operation can be performed for a stack set at a given time.

                                                                                                    func (*OperationInProgressException) Error

                                                                                                    func (*OperationInProgressException) ErrorCode

                                                                                                    func (e *OperationInProgressException) ErrorCode() string

                                                                                                    func (*OperationInProgressException) ErrorFault

                                                                                                    func (*OperationInProgressException) ErrorMessage

                                                                                                    func (e *OperationInProgressException) ErrorMessage() string

                                                                                                    type OperationNotFoundException

                                                                                                    type OperationNotFoundException struct {
                                                                                                    	Message *string
                                                                                                    }

                                                                                                      The specified ID refers to an operation that doesn't exist.

                                                                                                      func (*OperationNotFoundException) Error

                                                                                                      func (*OperationNotFoundException) ErrorCode

                                                                                                      func (e *OperationNotFoundException) ErrorCode() string

                                                                                                      func (*OperationNotFoundException) ErrorFault

                                                                                                      func (*OperationNotFoundException) ErrorMessage

                                                                                                      func (e *OperationNotFoundException) ErrorMessage() string

                                                                                                      type OperationStatus

                                                                                                      type OperationStatus string
                                                                                                      const (
                                                                                                      	OperationStatusPending    OperationStatus = "PENDING"
                                                                                                      	OperationStatusInProgress OperationStatus = "IN_PROGRESS"
                                                                                                      	OperationStatusSuccess    OperationStatus = "SUCCESS"
                                                                                                      	OperationStatusFailed     OperationStatus = "FAILED"
                                                                                                      )

                                                                                                        Enum values for OperationStatus

                                                                                                        func (OperationStatus) Values

                                                                                                        func (OperationStatus) Values() []OperationStatus

                                                                                                          Values returns all known values for OperationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                          type OperationStatusCheckFailedException

                                                                                                          type OperationStatusCheckFailedException struct {
                                                                                                          	Message *string
                                                                                                          }

                                                                                                            Error reserved for use by the CloudFormation CLI (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html). CloudFormation does not return this error to users.

                                                                                                            func (*OperationStatusCheckFailedException) Error

                                                                                                            func (*OperationStatusCheckFailedException) ErrorCode

                                                                                                            func (*OperationStatusCheckFailedException) ErrorFault

                                                                                                            func (*OperationStatusCheckFailedException) ErrorMessage

                                                                                                            func (e *OperationStatusCheckFailedException) ErrorMessage() string

                                                                                                            type Output

                                                                                                            type Output struct {
                                                                                                            
                                                                                                            	// User defined description associated with the output.
                                                                                                            	Description *string
                                                                                                            
                                                                                                            	// The name of the export associated with the output.
                                                                                                            	ExportName *string
                                                                                                            
                                                                                                            	// The key associated with the output.
                                                                                                            	OutputKey *string
                                                                                                            
                                                                                                            	// The value associated with the output.
                                                                                                            	OutputValue *string
                                                                                                            }

                                                                                                              The Output data type.

                                                                                                              type Parameter

                                                                                                              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
                                                                                                              
                                                                                                              	// The input value associated with the parameter.
                                                                                                              	ParameterValue *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
                                                                                                              
                                                                                                              	// 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
                                                                                                              }

                                                                                                                The Parameter data type.

                                                                                                                type ParameterConstraints

                                                                                                                type ParameterConstraints struct {
                                                                                                                
                                                                                                                	// A list of values that are permitted for a parameter.
                                                                                                                	AllowedValues []string
                                                                                                                }

                                                                                                                  A set of criteria that AWS CloudFormation uses to validate parameter values. Although other constraints might be defined in the stack template, AWS CloudFormation returns only the AllowedValues property.

                                                                                                                  type ParameterDeclaration

                                                                                                                  type ParameterDeclaration struct {
                                                                                                                  
                                                                                                                  	// The default value of the parameter.
                                                                                                                  	DefaultValue *string
                                                                                                                  
                                                                                                                  	// The description that is associate with the parameter.
                                                                                                                  	Description *string
                                                                                                                  
                                                                                                                  	// Flag that indicates whether the parameter value is shown as plain text in logs
                                                                                                                  	// and in the AWS Management Console.
                                                                                                                  	NoEcho *bool
                                                                                                                  
                                                                                                                  	// The criteria that AWS CloudFormation uses to validate parameter values.
                                                                                                                  	ParameterConstraints *ParameterConstraints
                                                                                                                  
                                                                                                                  	// The name that is associated with the parameter.
                                                                                                                  	ParameterKey *string
                                                                                                                  
                                                                                                                  	// The type of parameter.
                                                                                                                  	ParameterType *string
                                                                                                                  }

                                                                                                                    The ParameterDeclaration data type.

                                                                                                                    type PermissionModels

                                                                                                                    type PermissionModels string
                                                                                                                    const (
                                                                                                                    	PermissionModelsServiceManaged PermissionModels = "SERVICE_MANAGED"
                                                                                                                    	PermissionModelsSelfManaged    PermissionModels = "SELF_MANAGED"
                                                                                                                    )

                                                                                                                      Enum values for PermissionModels

                                                                                                                      func (PermissionModels) Values

                                                                                                                        Values returns all known values for PermissionModels. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                        type PhysicalResourceIdContextKeyValuePair

                                                                                                                        type PhysicalResourceIdContextKeyValuePair struct {
                                                                                                                        
                                                                                                                        	// The resource context key.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	Key *string
                                                                                                                        
                                                                                                                        	// The resource context value.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	Value *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 resource that contains the targeted resource.

                                                                                                                          type PropertyDifference

                                                                                                                          type PropertyDifference struct {
                                                                                                                          
                                                                                                                          	// 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
                                                                                                                          
                                                                                                                          	// 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 fully-qualified path to the resource property.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	PropertyPath *string
                                                                                                                          }

                                                                                                                            Information about a resource property whose actual value differs from its expected value, as defined in the stack template and any values specified as template parameters. These will be present only for resources whose StackResourceDriftStatus is MODIFIED. For more information, see Detecting Unregulated Configuration Changes to Stacks and Resources (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html).

                                                                                                                            type ProvisioningType

                                                                                                                            type ProvisioningType string
                                                                                                                            const (
                                                                                                                            	ProvisioningTypeNonProvisionable ProvisioningType = "NON_PROVISIONABLE"
                                                                                                                            	ProvisioningTypeImmutable        ProvisioningType = "IMMUTABLE"
                                                                                                                            	ProvisioningTypeFullyMutable     ProvisioningType = "FULLY_MUTABLE"
                                                                                                                            )

                                                                                                                              Enum values for ProvisioningType

                                                                                                                              func (ProvisioningType) Values

                                                                                                                                Values returns all known values for ProvisioningType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                type RegionConcurrencyType

                                                                                                                                type RegionConcurrencyType string
                                                                                                                                const (
                                                                                                                                	RegionConcurrencyTypeSequential RegionConcurrencyType = "SEQUENTIAL"
                                                                                                                                	RegionConcurrencyTypeParallel   RegionConcurrencyType = "PARALLEL"
                                                                                                                                )

                                                                                                                                  Enum values for RegionConcurrencyType

                                                                                                                                  func (RegionConcurrencyType) Values

                                                                                                                                    Values returns all known values for RegionConcurrencyType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                    type RegistrationStatus

                                                                                                                                    type RegistrationStatus string
                                                                                                                                    const (
                                                                                                                                    	RegistrationStatusComplete   RegistrationStatus = "COMPLETE"
                                                                                                                                    	RegistrationStatusInProgress RegistrationStatus = "IN_PROGRESS"
                                                                                                                                    	RegistrationStatusFailed     RegistrationStatus = "FAILED"
                                                                                                                                    )

                                                                                                                                      Enum values for RegistrationStatus

                                                                                                                                      func (RegistrationStatus) Values

                                                                                                                                        Values returns all known values for RegistrationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                        type RegistryType

                                                                                                                                        type RegistryType string
                                                                                                                                        const (
                                                                                                                                        	RegistryTypeResource RegistryType = "RESOURCE"
                                                                                                                                        	RegistryTypeModule   RegistryType = "MODULE"
                                                                                                                                        )

                                                                                                                                          Enum values for RegistryType

                                                                                                                                          func (RegistryType) Values

                                                                                                                                          func (RegistryType) Values() []RegistryType

                                                                                                                                            Values returns all known values for RegistryType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                            type Replacement

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

                                                                                                                                              Enum values for Replacement

                                                                                                                                              func (Replacement) Values

                                                                                                                                              func (Replacement) Values() []Replacement

                                                                                                                                                Values returns all known values for Replacement. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                type RequiresRecreation

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

                                                                                                                                                  Enum values for RequiresRecreation

                                                                                                                                                  func (RequiresRecreation) Values

                                                                                                                                                    Values returns all known values for RequiresRecreation. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                    type ResourceAttribute

                                                                                                                                                    type ResourceAttribute string
                                                                                                                                                    const (
                                                                                                                                                    	ResourceAttributeProperties     ResourceAttribute = "Properties"
                                                                                                                                                    	ResourceAttributeMetadata       ResourceAttribute = "Metadata"
                                                                                                                                                    	ResourceAttributeCreationPolicy ResourceAttribute = "CreationPolicy"
                                                                                                                                                    	ResourceAttributeUpdatePolicy   ResourceAttribute = "UpdatePolicy"
                                                                                                                                                    	ResourceAttributeDeletionPolicy ResourceAttribute = "DeletionPolicy"
                                                                                                                                                    	ResourceAttributeTags           ResourceAttribute = "Tags"
                                                                                                                                                    )

                                                                                                                                                      Enum values for ResourceAttribute

                                                                                                                                                      func (ResourceAttribute) Values

                                                                                                                                                        Values returns all known values for ResourceAttribute. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                        type ResourceChange

                                                                                                                                                        type ResourceChange struct {
                                                                                                                                                        
                                                                                                                                                        	// The action that AWS CloudFormation takes on the resource, such as Add (adds a
                                                                                                                                                        	// new resource), Modify (changes a resource), Remove (deletes a resource), Import
                                                                                                                                                        	// (imports a resource), or Dynamic (exact action for the resource cannot be
                                                                                                                                                        	// determined).
                                                                                                                                                        	Action ChangeAction
                                                                                                                                                        
                                                                                                                                                        	// The change set ID of the nested change set.
                                                                                                                                                        	ChangeSetId *string
                                                                                                                                                        
                                                                                                                                                        	// 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
                                                                                                                                                        
                                                                                                                                                        	// Contains information about the module from which the resource was created, if
                                                                                                                                                        	// the resource was created from a module included in the stack template.
                                                                                                                                                        	ModuleInfo *ModuleInfo
                                                                                                                                                        
                                                                                                                                                        	// 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 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
                                                                                                                                                        }

                                                                                                                                                          The ResourceChange structure describes the resource and the action that AWS CloudFormation will perform on it if you execute this change set.

                                                                                                                                                          type ResourceChangeDetail

                                                                                                                                                          type ResourceChangeDetail struct {
                                                                                                                                                          
                                                                                                                                                          	// 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
                                                                                                                                                          
                                                                                                                                                          	// 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
                                                                                                                                                          
                                                                                                                                                          	// 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
                                                                                                                                                          
                                                                                                                                                          	// A ResourceTargetDefinition structure that describes the field that AWS
                                                                                                                                                          	// CloudFormation will change and whether the resource will be recreated.
                                                                                                                                                          	Target *ResourceTargetDefinition
                                                                                                                                                          }

                                                                                                                                                            For a resource with Modify as the action, the ResourceChange structure describes the changes AWS CloudFormation will make to that resource.

                                                                                                                                                            type ResourceIdentifierSummary

                                                                                                                                                            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
                                                                                                                                                            }

                                                                                                                                                              Describes the target resources of a specific type in your import template (for example, all AWS::S3::Bucket resources) and the properties you can provide during the import to identify resources of that type.

                                                                                                                                                              type ResourceSignalStatus

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

                                                                                                                                                                Enum values for ResourceSignalStatus

                                                                                                                                                                func (ResourceSignalStatus) Values

                                                                                                                                                                  Values returns all known values for ResourceSignalStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                  type ResourceStatus

                                                                                                                                                                  type ResourceStatus string
                                                                                                                                                                  const (
                                                                                                                                                                  	ResourceStatusCreateInProgress         ResourceStatus = "CREATE_IN_PROGRESS"
                                                                                                                                                                  	ResourceStatusCreateFailed             ResourceStatus = "CREATE_FAILED"
                                                                                                                                                                  	ResourceStatusCreateComplete           ResourceStatus = "CREATE_COMPLETE"
                                                                                                                                                                  	ResourceStatusDeleteInProgress         ResourceStatus = "DELETE_IN_PROGRESS"
                                                                                                                                                                  	ResourceStatusDeleteFailed             ResourceStatus = "DELETE_FAILED"
                                                                                                                                                                  	ResourceStatusDeleteComplete           ResourceStatus = "DELETE_COMPLETE"
                                                                                                                                                                  	ResourceStatusDeleteSkipped            ResourceStatus = "DELETE_SKIPPED"
                                                                                                                                                                  	ResourceStatusUpdateInProgress         ResourceStatus = "UPDATE_IN_PROGRESS"
                                                                                                                                                                  	ResourceStatusUpdateFailed             ResourceStatus = "UPDATE_FAILED"
                                                                                                                                                                  	ResourceStatusUpdateComplete           ResourceStatus = "UPDATE_COMPLETE"
                                                                                                                                                                  	ResourceStatusImportFailed             ResourceStatus = "IMPORT_FAILED"
                                                                                                                                                                  	ResourceStatusImportComplete           ResourceStatus = "IMPORT_COMPLETE"
                                                                                                                                                                  	ResourceStatusImportInProgress         ResourceStatus = "IMPORT_IN_PROGRESS"
                                                                                                                                                                  	ResourceStatusImportRollbackInProgress ResourceStatus = "IMPORT_ROLLBACK_IN_PROGRESS"
                                                                                                                                                                  	ResourceStatusImportRollbackFailed     ResourceStatus = "IMPORT_ROLLBACK_FAILED"
                                                                                                                                                                  	ResourceStatusImportRollbackComplete   ResourceStatus = "IMPORT_ROLLBACK_COMPLETE"
                                                                                                                                                                  )

                                                                                                                                                                    Enum values for ResourceStatus

                                                                                                                                                                    func (ResourceStatus) Values

                                                                                                                                                                    func (ResourceStatus) Values() []ResourceStatus

                                                                                                                                                                      Values returns all known values for ResourceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                      type ResourceTargetDefinition

                                                                                                                                                                      type ResourceTargetDefinition struct {
                                                                                                                                                                      
                                                                                                                                                                      	// Indicates which resource attribute is triggering this update, such as a change
                                                                                                                                                                      	// in the resource attribute's Metadata, Properties, or Tags.
                                                                                                                                                                      	Attribute ResourceAttribute
                                                                                                                                                                      
                                                                                                                                                                      	// 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
                                                                                                                                                                      }

                                                                                                                                                                        The field that AWS CloudFormation will change, such as the name of a resource's property, and whether the resource will be recreated.

                                                                                                                                                                        type ResourceToImport

                                                                                                                                                                        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
                                                                                                                                                                        }

                                                                                                                                                                          Describes the target resource of an import operation.

                                                                                                                                                                          type RollbackConfiguration

                                                                                                                                                                          type RollbackConfiguration struct {
                                                                                                                                                                          
                                                                                                                                                                          	// 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
                                                                                                                                                                          
                                                                                                                                                                          	// 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
                                                                                                                                                                          }

                                                                                                                                                                            Structure containing the rollback triggers for AWS CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards. Rollback triggers enable you to have AWS CloudFormation monitor the state of your application during stack creation and updating, and to roll back that operation if the application breaches the threshold of any of the alarms you've specified. For more information, see Monitor and Roll Back Stack Operations (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-rollback-triggers.html).

                                                                                                                                                                            type RollbackTrigger

                                                                                                                                                                            type RollbackTrigger struct {
                                                                                                                                                                            
                                                                                                                                                                            	// 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
                                                                                                                                                                            
                                                                                                                                                                            	// 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
                                                                                                                                                                            }

                                                                                                                                                                              A rollback trigger AWS CloudFormation monitors during creation and updating of stacks. If any of the alarms you specify goes to ALARM state during the stack operation or within the specified monitoring period afterwards, CloudFormation rolls back the entire stack operation.

                                                                                                                                                                              type Stack

                                                                                                                                                                              type Stack struct {
                                                                                                                                                                              
                                                                                                                                                                              	// The time at which the stack was created.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	CreationTime *time.Time
                                                                                                                                                                              
                                                                                                                                                                              	// The name associated with the stack.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	StackName *string
                                                                                                                                                                              
                                                                                                                                                                              	// Current status of the stack.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	StackStatus StackStatus
                                                                                                                                                                              
                                                                                                                                                                              	// The capabilities allowed in the stack.
                                                                                                                                                                              	Capabilities []Capability
                                                                                                                                                                              
                                                                                                                                                                              	// The unique ID of the change set.
                                                                                                                                                                              	ChangeSetId *string
                                                                                                                                                                              
                                                                                                                                                                              	// The time the stack was deleted.
                                                                                                                                                                              	DeletionTime *time.Time
                                                                                                                                                                              
                                                                                                                                                                              	// A user-defined description associated with the stack.
                                                                                                                                                                              	Description *string
                                                                                                                                                                              
                                                                                                                                                                              	// Boolean to enable or disable rollback on stack creation failures:
                                                                                                                                                                              	//
                                                                                                                                                                              	// * true:
                                                                                                                                                                              	// disable rollback
                                                                                                                                                                              	//
                                                                                                                                                                              	// * false: enable rollback
                                                                                                                                                                              	DisableRollback *bool
                                                                                                                                                                              
                                                                                                                                                                              	// 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
                                                                                                                                                                              
                                                                                                                                                                              	// 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
                                                                                                                                                                              
                                                                                                                                                                              	// 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
                                                                                                                                                                              
                                                                                                                                                                              	// SNS topic ARNs to which stack related events are published.
                                                                                                                                                                              	NotificationARNs []string
                                                                                                                                                                              
                                                                                                                                                                              	// A list of output structures.
                                                                                                                                                                              	Outputs []Output
                                                                                                                                                                              
                                                                                                                                                                              	// A list of Parameter structures.
                                                                                                                                                                              	Parameters []Parameter
                                                                                                                                                                              
                                                                                                                                                                              	// 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
                                                                                                                                                                              
                                                                                                                                                                              	// 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
                                                                                                                                                                              
                                                                                                                                                                              	// The rollback triggers for AWS CloudFormation to monitor during stack creation
                                                                                                                                                                              	// and updating operations, and for the specified monitoring period afterwards.
                                                                                                                                                                              	RollbackConfiguration *RollbackConfiguration
                                                                                                                                                                              
                                                                                                                                                                              	// 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
                                                                                                                                                                              
                                                                                                                                                                              	// Unique identifier of the stack.
                                                                                                                                                                              	StackId *string
                                                                                                                                                                              
                                                                                                                                                                              	// Success/failure message associated with the stack status.
                                                                                                                                                                              	StackStatusReason *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 Stack data type.

                                                                                                                                                                                type StackDriftDetectionStatus

                                                                                                                                                                                type StackDriftDetectionStatus string
                                                                                                                                                                                const (
                                                                                                                                                                                	StackDriftDetectionStatusDetectionInProgress StackDriftDetectionStatus = "DETECTION_IN_PROGRESS"
                                                                                                                                                                                	StackDriftDetectionStatusDetectionFailed     StackDriftDetectionStatus = "DETECTION_FAILED"
                                                                                                                                                                                	StackDriftDetectionStatusDetectionComplete   StackDriftDetectionStatus = "DETECTION_COMPLETE"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for StackDriftDetectionStatus

                                                                                                                                                                                  func (StackDriftDetectionStatus) Values

                                                                                                                                                                                    Values returns all known values for StackDriftDetectionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                    type StackDriftInformation

                                                                                                                                                                                    type StackDriftInformation 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
                                                                                                                                                                                    }

                                                                                                                                                                                      Contains information about whether the stack's actual configuration differs, or has drifted, from its expected configuration, as defined in the stack template and any values specified as template parameters. A stack is considered to have drifted if one or more of its resources have drifted.

                                                                                                                                                                                      type StackDriftInformationSummary

                                                                                                                                                                                      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
                                                                                                                                                                                      }

                                                                                                                                                                                        Contains information about whether the stack's actual configuration differs, or has drifted, from its expected configuration, as defined in the stack template and any values specified as template parameters. A stack is considered to have drifted if one or more of its resources have drifted.

                                                                                                                                                                                        type StackDriftStatus

                                                                                                                                                                                        type StackDriftStatus string
                                                                                                                                                                                        const (
                                                                                                                                                                                        	StackDriftStatusDrifted    StackDriftStatus = "DRIFTED"
                                                                                                                                                                                        	StackDriftStatusInSync     StackDriftStatus = "IN_SYNC"
                                                                                                                                                                                        	StackDriftStatusUnknown    StackDriftStatus = "UNKNOWN"
                                                                                                                                                                                        	StackDriftStatusNotChecked StackDriftStatus = "NOT_CHECKED"
                                                                                                                                                                                        )

                                                                                                                                                                                          Enum values for StackDriftStatus

                                                                                                                                                                                          func (StackDriftStatus) Values

                                                                                                                                                                                            Values returns all known values for StackDriftStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                            type StackEvent

                                                                                                                                                                                            type StackEvent struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The unique ID of this event.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	EventId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The unique ID name of the instance of the stack.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	StackId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The name associated with a stack.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	StackName *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// Time the status was updated.
                                                                                                                                                                                            	//
                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                            	Timestamp *time.Time
                                                                                                                                                                                            
                                                                                                                                                                                            	// 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
                                                                                                                                                                                            
                                                                                                                                                                                            	// The logical name of the resource specified in the template.
                                                                                                                                                                                            	LogicalResourceId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The name or unique identifier associated with the physical instance of the
                                                                                                                                                                                            	// resource.
                                                                                                                                                                                            	PhysicalResourceId *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// BLOB of the properties used to create the resource.
                                                                                                                                                                                            	ResourceProperties *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// Current status of the resource.
                                                                                                                                                                                            	ResourceStatus ResourceStatus
                                                                                                                                                                                            
                                                                                                                                                                                            	// Success/failure message associated with the resource.
                                                                                                                                                                                            	ResourceStatusReason *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.)
                                                                                                                                                                                            	ResourceType *string
                                                                                                                                                                                            }

                                                                                                                                                                                              The StackEvent data type.

                                                                                                                                                                                              type StackInstance

                                                                                                                                                                                              type StackInstance struct {
                                                                                                                                                                                              
                                                                                                                                                                                              	// [Self-managed permissions] The name of the AWS account that the stack instance
                                                                                                                                                                                              	// is associated with.
                                                                                                                                                                                              	Account *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
                                                                                                                                                                                              
                                                                                                                                                                                              	// 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
                                                                                                                                                                                              
                                                                                                                                                                                              	// A list of parameters from the stack set template whose values have been
                                                                                                                                                                                              	// overridden in this stack instance.
                                                                                                                                                                                              	ParameterOverrides []Parameter
                                                                                                                                                                                              
                                                                                                                                                                                              	// The name of the AWS Region that the stack instance is associated with.
                                                                                                                                                                                              	Region *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The ID of the stack instance.
                                                                                                                                                                                              	StackId *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// The detailed status of the stack instance.
                                                                                                                                                                                              	StackInstanceStatus *StackInstanceComprehensiveStatus
                                                                                                                                                                                              
                                                                                                                                                                                              	// The name or unique ID of the stack set that the stack instance is associated
                                                                                                                                                                                              	// with.
                                                                                                                                                                                              	StackSetId *string
                                                                                                                                                                                              
                                                                                                                                                                                              	// 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 that is assigned to this stack
                                                                                                                                                                                              	// instance.
                                                                                                                                                                                              	StatusReason *string
                                                                                                                                                                                              }

                                                                                                                                                                                                An AWS CloudFormation stack, in a specific account and Region, that's part of a stack set operation. A stack instance is a reference to an attempted or actual stack in a given account within a given Region. A stack instance can exist without a stack—for example, if the stack couldn't be created for some reason. A stack instance is associated with only one stack set. Each stack instance contains the ID of its associated stack set, as well as the ID of the actual stack and the stack status.

                                                                                                                                                                                                type 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
                                                                                                                                                                                                }

                                                                                                                                                                                                  The detailed status of the stack instance.

                                                                                                                                                                                                  type StackInstanceDetailedStatus

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

                                                                                                                                                                                                    Enum values for StackInstanceDetailedStatus

                                                                                                                                                                                                    func (StackInstanceDetailedStatus) Values

                                                                                                                                                                                                      Values returns all known values for StackInstanceDetailedStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                      type StackInstanceFilter

                                                                                                                                                                                                      type StackInstanceFilter struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The type of filter to apply.
                                                                                                                                                                                                      	Name StackInstanceFilterName
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The status to filter by.
                                                                                                                                                                                                      	Values *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                        The status that stack instances are filtered by.

                                                                                                                                                                                                        type StackInstanceFilterName

                                                                                                                                                                                                        type StackInstanceFilterName string
                                                                                                                                                                                                        const (
                                                                                                                                                                                                        	StackInstanceFilterNameDetailedStatus StackInstanceFilterName = "DETAILED_STATUS"
                                                                                                                                                                                                        )

                                                                                                                                                                                                          Enum values for StackInstanceFilterName

                                                                                                                                                                                                          func (StackInstanceFilterName) Values

                                                                                                                                                                                                            Values returns all known values for StackInstanceFilterName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                            type StackInstanceNotFoundException

                                                                                                                                                                                                            type StackInstanceNotFoundException struct {
                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              The specified stack instance doesn't exist.

                                                                                                                                                                                                              func (*StackInstanceNotFoundException) Error

                                                                                                                                                                                                              func (*StackInstanceNotFoundException) ErrorCode

                                                                                                                                                                                                              func (e *StackInstanceNotFoundException) ErrorCode() string

                                                                                                                                                                                                              func (*StackInstanceNotFoundException) ErrorFault

                                                                                                                                                                                                              func (*StackInstanceNotFoundException) ErrorMessage

                                                                                                                                                                                                              func (e *StackInstanceNotFoundException) ErrorMessage() string

                                                                                                                                                                                                              type StackInstanceStatus

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

                                                                                                                                                                                                                Enum values for StackInstanceStatus

                                                                                                                                                                                                                func (StackInstanceStatus) Values

                                                                                                                                                                                                                  Values returns all known values for StackInstanceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                  type StackInstanceSummary

                                                                                                                                                                                                                  type StackInstanceSummary struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// [Self-managed permissions] The name of the AWS account that the stack instance
                                                                                                                                                                                                                  	// is associated with.
                                                                                                                                                                                                                  	Account *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
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// 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 of the AWS Region that the stack instance is associated with.
                                                                                                                                                                                                                  	Region *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The ID of the stack instance.
                                                                                                                                                                                                                  	StackId *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The detailed status of the stack instance.
                                                                                                                                                                                                                  	StackInstanceStatus *StackInstanceComprehensiveStatus
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The name or unique ID of the stack set that the stack instance is associated
                                                                                                                                                                                                                  	// with.
                                                                                                                                                                                                                  	StackSetId *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// 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
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    The structure that contains summary information about a stack instance.

                                                                                                                                                                                                                    type StackResource

                                                                                                                                                                                                                    type StackResource struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The logical name of the resource specified in the template.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                    	LogicalResourceId *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
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Contains information about the module from which the resource was created, if
                                                                                                                                                                                                                    	// the resource was created from a module included in the stack template.
                                                                                                                                                                                                                    	ModuleInfo *ModuleInfo
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The name or unique identifier that corresponds to a physical instance ID of a
                                                                                                                                                                                                                    	// resource supported by AWS CloudFormation.
                                                                                                                                                                                                                    	PhysicalResourceId *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Success/failure message associated with the resource.
                                                                                                                                                                                                                    	ResourceStatusReason *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// Unique identifier of the stack.
                                                                                                                                                                                                                    	StackId *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The name associated with the stack.
                                                                                                                                                                                                                    	StackName *string
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      The StackResource data type.

                                                                                                                                                                                                                      type StackResourceDetail

                                                                                                                                                                                                                      type StackResourceDetail struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Time the status was updated.
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	LastUpdatedTimestamp *time.Time
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The logical name of the resource specified in the template.
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	LogicalResourceId *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
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// 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 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
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Contains information about the module from which the resource was created, if
                                                                                                                                                                                                                      	// the resource was created from a module included in the stack template.
                                                                                                                                                                                                                      	ModuleInfo *ModuleInfo
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The name or unique identifier that corresponds to a physical instance ID of a
                                                                                                                                                                                                                      	// resource supported by AWS CloudFormation.
                                                                                                                                                                                                                      	PhysicalResourceId *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Success/failure message associated with the resource.
                                                                                                                                                                                                                      	ResourceStatusReason *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Unique identifier of the stack.
                                                                                                                                                                                                                      	StackId *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The name associated with the stack.
                                                                                                                                                                                                                      	StackName *string
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        Contains detailed information about the specified stack resource.

                                                                                                                                                                                                                        type StackResourceDrift

                                                                                                                                                                                                                        type StackResourceDrift struct {
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The logical name of the resource specified in the template.
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                        	LogicalResourceId *string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The type of the resource.
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                        	ResourceType *string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The ID of the stack.
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                        	StackId *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
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Time at which AWS CloudFormation performed drift detection on the stack
                                                                                                                                                                                                                        	// resource.
                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                        	Timestamp *time.Time
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// 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
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// 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
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Contains information about the module from which the resource was created, if
                                                                                                                                                                                                                        	// the resource was created from a module included in the stack template.
                                                                                                                                                                                                                        	ModuleInfo *ModuleInfo
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The name or unique identifier that corresponds to a physical instance ID of a
                                                                                                                                                                                                                        	// resource supported by AWS CloudFormation.
                                                                                                                                                                                                                        	PhysicalResourceId *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 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
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Contains the drift information for a resource that has been checked for drift. This includes actual and expected property values for resources in which AWS CloudFormation has detected drift. Only resource properties explicitly defined in the stack template are checked for drift. For more information, see Detecting Unregulated Configuration Changes to Stacks and Resources (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html). Resources that do not currently support drift detection cannot be checked. For a list of resources that support drift detection, see Resources that Support Drift Detection (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html). Use DetectStackResourceDrift to detect drift on individual resources, or DetectStackDrift to detect drift on all resources in a given stack that support drift detection.

                                                                                                                                                                                                                          type StackResourceDriftInformation

                                                                                                                                                                                                                          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
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            Contains information about whether the resource's actual configuration differs, or has drifted, from its expected configuration.

                                                                                                                                                                                                                            type StackResourceDriftInformationSummary

                                                                                                                                                                                                                            type StackResourceDriftInformationSummary 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).
                                                                                                                                                                                                                            	// 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
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// When AWS CloudFormation last checked if the resource had drifted from its
                                                                                                                                                                                                                            	// expected configuration.
                                                                                                                                                                                                                            	LastCheckTimestamp *time.Time
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Summarizes information about whether the resource's actual configuration differs, or has drifted, from its expected configuration.

                                                                                                                                                                                                                              type StackResourceDriftStatus

                                                                                                                                                                                                                              type StackResourceDriftStatus string
                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                              	StackResourceDriftStatusInSync     StackResourceDriftStatus = "IN_SYNC"
                                                                                                                                                                                                                              	StackResourceDriftStatusModified   StackResourceDriftStatus = "MODIFIED"
                                                                                                                                                                                                                              	StackResourceDriftStatusDeleted    StackResourceDriftStatus = "DELETED"
                                                                                                                                                                                                                              	StackResourceDriftStatusNotChecked StackResourceDriftStatus = "NOT_CHECKED"
                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                Enum values for StackResourceDriftStatus

                                                                                                                                                                                                                                func (StackResourceDriftStatus) Values

                                                                                                                                                                                                                                  Values returns all known values for StackResourceDriftStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                  type StackResourceSummary

                                                                                                                                                                                                                                  type StackResourceSummary struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Time the status was updated.
                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                  	LastUpdatedTimestamp *time.Time
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The logical name of the resource specified in the template.
                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                  	LogicalResourceId *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
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// 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
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Contains information about the module from which the resource was created, if
                                                                                                                                                                                                                                  	// the resource was created from a module included in the stack template.
                                                                                                                                                                                                                                  	ModuleInfo *ModuleInfo
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The name or unique identifier that corresponds to a physical instance ID of the
                                                                                                                                                                                                                                  	// resource.
                                                                                                                                                                                                                                  	PhysicalResourceId *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// Success/failure message associated with the resource.
                                                                                                                                                                                                                                  	ResourceStatusReason *string
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    Contains high-level information about the specified stack resource.

                                                                                                                                                                                                                                    type StackSet

                                                                                                                                                                                                                                    type StackSet struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// 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] Describes whether StackSets automatically deploys
                                                                                                                                                                                                                                    	// to AWS Organizations accounts that are added to a target organization or
                                                                                                                                                                                                                                    	// organizational unit (OU).
                                                                                                                                                                                                                                    	AutoDeployment *AutoDeployment
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// A description of the stack set that you specify when the stack set is created or
                                                                                                                                                                                                                                    	// updated.
                                                                                                                                                                                                                                    	Description *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
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// [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 input parameters for a stack set.
                                                                                                                                                                                                                                    	Parameters []Parameter
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The Amazon Resource Number (ARN) of the stack set.
                                                                                                                                                                                                                                    	StackSetARN *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The ID of the stack set.
                                                                                                                                                                                                                                    	StackSetId *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The name that's associated with the stack set.
                                                                                                                                                                                                                                    	StackSetName *string
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The status of the stack set.
                                                                                                                                                                                                                                    	Status StackSetStatus
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// A list of tags that specify information about the stack set. A maximum number of
                                                                                                                                                                                                                                    	// 50 tags can be specified.
                                                                                                                                                                                                                                    	Tags []Tag
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The structure that contains the body of the template that was used to create or
                                                                                                                                                                                                                                    	// update the stack set.
                                                                                                                                                                                                                                    	TemplateBody *string
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      A structure that contains information about a stack set. A stack set enables you to provision stacks into AWS accounts and across Regions by using a single CloudFormation template. In the stack set, you specify the template to use, as well as any parameters and capabilities that the template requires.

                                                                                                                                                                                                                                      type StackSetDriftDetectionDetails

                                                                                                                                                                                                                                      type StackSetDriftDetectionDetails struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// 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 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 for which the drift detection operation failed.
                                                                                                                                                                                                                                      	FailedStackInstancesCount int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The number of stack instances that are currently being checked for drift.
                                                                                                                                                                                                                                      	InProgressStackInstancesCount int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The number of stack instances which match the expected template and parameter
                                                                                                                                                                                                                                      	// configuration of the stack set.
                                                                                                                                                                                                                                      	InSyncStackInstancesCount 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
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// 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
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        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 in-progress is not included. For stack set operations, includes information about drift operations currently being performed on the stack set. 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.

                                                                                                                                                                                                                                        type StackSetDriftDetectionStatus

                                                                                                                                                                                                                                        type StackSetDriftDetectionStatus string
                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                        	StackSetDriftDetectionStatusCompleted      StackSetDriftDetectionStatus = "COMPLETED"
                                                                                                                                                                                                                                        	StackSetDriftDetectionStatusFailed         StackSetDriftDetectionStatus = "FAILED"
                                                                                                                                                                                                                                        	StackSetDriftDetectionStatusPartialSuccess StackSetDriftDetectionStatus = "PARTIAL_SUCCESS"
                                                                                                                                                                                                                                        	StackSetDriftDetectionStatusInProgress     StackSetDriftDetectionStatus = "IN_PROGRESS"
                                                                                                                                                                                                                                        	StackSetDriftDetectionStatusStopped        StackSetDriftDetectionStatus = "STOPPED"
                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                          Enum values for StackSetDriftDetectionStatus

                                                                                                                                                                                                                                          func (StackSetDriftDetectionStatus) Values

                                                                                                                                                                                                                                            Values returns all known values for StackSetDriftDetectionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                            type StackSetDriftStatus

                                                                                                                                                                                                                                            type StackSetDriftStatus string
                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                            	StackSetDriftStatusDrifted    StackSetDriftStatus = "DRIFTED"
                                                                                                                                                                                                                                            	StackSetDriftStatusInSync     StackSetDriftStatus = "IN_SYNC"
                                                                                                                                                                                                                                            	StackSetDriftStatusNotChecked StackSetDriftStatus = "NOT_CHECKED"
                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                              Enum values for StackSetDriftStatus

                                                                                                                                                                                                                                              func (StackSetDriftStatus) Values

                                                                                                                                                                                                                                                Values returns all known values for StackSetDriftStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                type StackSetNotEmptyException

                                                                                                                                                                                                                                                type StackSetNotEmptyException struct {
                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  You can't yet delete this stack set, because it still contains one or more stack instances. Delete all stack instances from the stack set before deleting the stack set.

                                                                                                                                                                                                                                                  func (*StackSetNotEmptyException) Error

                                                                                                                                                                                                                                                  func (e *StackSetNotEmptyException) Error() string

                                                                                                                                                                                                                                                  func (*StackSetNotEmptyException) ErrorCode

                                                                                                                                                                                                                                                  func (e *StackSetNotEmptyException) ErrorCode() string

                                                                                                                                                                                                                                                  func (*StackSetNotEmptyException) ErrorFault

                                                                                                                                                                                                                                                  func (*StackSetNotEmptyException) ErrorMessage

                                                                                                                                                                                                                                                  func (e *StackSetNotEmptyException) ErrorMessage() string

                                                                                                                                                                                                                                                  type StackSetNotFoundException

                                                                                                                                                                                                                                                  type StackSetNotFoundException struct {
                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    The specified stack set doesn't exist.

                                                                                                                                                                                                                                                    func (*StackSetNotFoundException) Error

                                                                                                                                                                                                                                                    func (e *StackSetNotFoundException) Error() string

                                                                                                                                                                                                                                                    func (*StackSetNotFoundException) ErrorCode

                                                                                                                                                                                                                                                    func (e *StackSetNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                    func (*StackSetNotFoundException) ErrorFault

                                                                                                                                                                                                                                                    func (*StackSetNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                    func (e *StackSetNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                    type StackSetOperation

                                                                                                                                                                                                                                                    type StackSetOperation struct {
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// 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 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
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// [Service-managed permissions] The AWS Organizations accounts affected by the
                                                                                                                                                                                                                                                    	// stack operation.
                                                                                                                                                                                                                                                    	DeploymentTargets *DeploymentTargets
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The preferences for how AWS CloudFormation performs this stack set operation.
                                                                                                                                                                                                                                                    	OperationPreferences *StackSetOperationPreferences
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// 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
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// 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 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
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      The structure that contains information about a stack set operation.

                                                                                                                                                                                                                                                      type StackSetOperationAction

                                                                                                                                                                                                                                                      type StackSetOperationAction string
                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                      	StackSetOperationActionCreate      StackSetOperationAction = "CREATE"
                                                                                                                                                                                                                                                      	StackSetOperationActionUpdate      StackSetOperationAction = "UPDATE"
                                                                                                                                                                                                                                                      	StackSetOperationActionDelete      StackSetOperationAction = "DELETE"
                                                                                                                                                                                                                                                      	StackSetOperationActionDetectDrift StackSetOperationAction = "DETECT_DRIFT"
                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                        Enum values for StackSetOperationAction

                                                                                                                                                                                                                                                        func (StackSetOperationAction) Values

                                                                                                                                                                                                                                                          Values returns all known values for StackSetOperationAction. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                          type StackSetOperationPreferences

                                                                                                                                                                                                                                                          type StackSetOperationPreferences struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// 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 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 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
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	RegionConcurrencyType RegionConcurrencyType
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The order of the Regions in where you want to perform the stack operation.
                                                                                                                                                                                                                                                          	RegionOrder []string
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            The user-specified preferences for how AWS CloudFormation performs a stack set operation. For more information on maximum concurrent accounts and failure tolerance, see Stack set operation options (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-ops-options).

                                                                                                                                                                                                                                                            type StackSetOperationResultStatus

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

                                                                                                                                                                                                                                                              Enum values for StackSetOperationResultStatus

                                                                                                                                                                                                                                                              func (StackSetOperationResultStatus) Values

                                                                                                                                                                                                                                                                Values returns all known values for StackSetOperationResultStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                type StackSetOperationResultSummary

                                                                                                                                                                                                                                                                type StackSetOperationResultSummary struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// [Self-managed permissions] The name of the AWS account for this operation
                                                                                                                                                                                                                                                                	// result.
                                                                                                                                                                                                                                                                	Account *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The results of the account gate function AWS CloudFormation invokes, if present,
                                                                                                                                                                                                                                                                	// before proceeding with stack set operations in an account
                                                                                                                                                                                                                                                                	AccountGateResult *AccountGateResult
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// [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 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
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The reason for the assigned result status.
                                                                                                                                                                                                                                                                	StatusReason *string
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  The structure that contains information about a specified operation's results for a given account in a given Region.

                                                                                                                                                                                                                                                                  type StackSetOperationStatus

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

                                                                                                                                                                                                                                                                    Enum values for StackSetOperationStatus

                                                                                                                                                                                                                                                                    func (StackSetOperationStatus) Values

                                                                                                                                                                                                                                                                      Values returns all known values for StackSetOperationStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                      type StackSetOperationSummary

                                                                                                                                                                                                                                                                      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 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
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// The unique ID of the stack set operation.
                                                                                                                                                                                                                                                                      	OperationId *string
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// 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 structures that contain summary information about the specified operation.

                                                                                                                                                                                                                                                                        type StackSetStatus

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

                                                                                                                                                                                                                                                                          Enum values for StackSetStatus

                                                                                                                                                                                                                                                                          func (StackSetStatus) Values

                                                                                                                                                                                                                                                                          func (StackSetStatus) Values() []StackSetStatus

                                                                                                                                                                                                                                                                            Values returns all known values for StackSetStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                            type StackSetSummary

                                                                                                                                                                                                                                                                            type StackSetSummary struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// [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
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// 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
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// 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
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// 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
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The ID of the stack set.
                                                                                                                                                                                                                                                                            	StackSetId *string
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The name of the stack set.
                                                                                                                                                                                                                                                                            	StackSetName *string
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The status of the stack set.
                                                                                                                                                                                                                                                                            	Status StackSetStatus
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              The structures that contain summary information about the specified stack set.

                                                                                                                                                                                                                                                                              type StackStatus

                                                                                                                                                                                                                                                                              type StackStatus string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	StackStatusCreateInProgress                        StackStatus = "CREATE_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusCreateFailed                            StackStatus = "CREATE_FAILED"
                                                                                                                                                                                                                                                                              	StackStatusCreateComplete                          StackStatus = "CREATE_COMPLETE"
                                                                                                                                                                                                                                                                              	StackStatusRollbackInProgress                      StackStatus = "ROLLBACK_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusRollbackFailed                          StackStatus = "ROLLBACK_FAILED"
                                                                                                                                                                                                                                                                              	StackStatusRollbackComplete                        StackStatus = "ROLLBACK_COMPLETE"
                                                                                                                                                                                                                                                                              	StackStatusDeleteInProgress                        StackStatus = "DELETE_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusDeleteFailed                            StackStatus = "DELETE_FAILED"
                                                                                                                                                                                                                                                                              	StackStatusDeleteComplete                          StackStatus = "DELETE_COMPLETE"
                                                                                                                                                                                                                                                                              	StackStatusUpdateInProgress                        StackStatus = "UPDATE_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusUpdateCompleteCleanupInProgress         StackStatus = "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusUpdateComplete                          StackStatus = "UPDATE_COMPLETE"
                                                                                                                                                                                                                                                                              	StackStatusUpdateRollbackInProgress                StackStatus = "UPDATE_ROLLBACK_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusUpdateRollbackFailed                    StackStatus = "UPDATE_ROLLBACK_FAILED"
                                                                                                                                                                                                                                                                              	StackStatusUpdateRollbackCompleteCleanupInProgress StackStatus = "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusUpdateRollbackComplete                  StackStatus = "UPDATE_ROLLBACK_COMPLETE"
                                                                                                                                                                                                                                                                              	StackStatusReviewInProgress                        StackStatus = "REVIEW_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusImportInProgress                        StackStatus = "IMPORT_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusImportComplete                          StackStatus = "IMPORT_COMPLETE"
                                                                                                                                                                                                                                                                              	StackStatusImportRollbackInProgress                StackStatus = "IMPORT_ROLLBACK_IN_PROGRESS"
                                                                                                                                                                                                                                                                              	StackStatusImportRollbackFailed                    StackStatus = "IMPORT_ROLLBACK_FAILED"
                                                                                                                                                                                                                                                                              	StackStatusImportRollbackComplete                  StackStatus = "IMPORT_ROLLBACK_COMPLETE"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for StackStatus

                                                                                                                                                                                                                                                                                func (StackStatus) Values

                                                                                                                                                                                                                                                                                func (StackStatus) Values() []StackStatus

                                                                                                                                                                                                                                                                                  Values returns all known values for StackStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                  type StackSummary

                                                                                                                                                                                                                                                                                  type StackSummary struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The time the stack was created.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	CreationTime *time.Time
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The name associated with the stack.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	StackName *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The current status of the stack.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	StackStatus StackStatus
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The time the stack was deleted.
                                                                                                                                                                                                                                                                                  	DeletionTime *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 last updated. This field will only be returned if the
                                                                                                                                                                                                                                                                                  	// stack has been updated at least once.
                                                                                                                                                                                                                                                                                  	LastUpdatedTime *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
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// Unique stack identifier.
                                                                                                                                                                                                                                                                                  	StackId *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// Success/Failure message associated with the stack status.
                                                                                                                                                                                                                                                                                  	StackStatusReason *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The template description of the template used to create the stack.
                                                                                                                                                                                                                                                                                  	TemplateDescription *string
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    The StackSummary Data Type

                                                                                                                                                                                                                                                                                    type StaleRequestException

                                                                                                                                                                                                                                                                                    type StaleRequestException struct {
                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      Another operation has been performed on this stack set since the specified operation was performed.

                                                                                                                                                                                                                                                                                      func (*StaleRequestException) Error

                                                                                                                                                                                                                                                                                      func (e *StaleRequestException) Error() string

                                                                                                                                                                                                                                                                                      func (*StaleRequestException) ErrorCode

                                                                                                                                                                                                                                                                                      func (e *StaleRequestException) ErrorCode() string

                                                                                                                                                                                                                                                                                      func (*StaleRequestException) ErrorFault

                                                                                                                                                                                                                                                                                      func (e *StaleRequestException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                      func (*StaleRequestException) ErrorMessage

                                                                                                                                                                                                                                                                                      func (e *StaleRequestException) ErrorMessage() string

                                                                                                                                                                                                                                                                                      type Tag

                                                                                                                                                                                                                                                                                      type Tag struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// 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
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// 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
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        The Tag type enables you to specify a key-value pair that can be used to store information about an AWS CloudFormation stack.

                                                                                                                                                                                                                                                                                        type TemplateParameter

                                                                                                                                                                                                                                                                                        type TemplateParameter struct {
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The default value associated with the parameter.
                                                                                                                                                                                                                                                                                        	DefaultValue *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// User defined description associated with the parameter.
                                                                                                                                                                                                                                                                                        	Description *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// Flag indicating whether the parameter should be displayed as plain text in logs
                                                                                                                                                                                                                                                                                        	// and UIs.
                                                                                                                                                                                                                                                                                        	NoEcho *bool
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The name associated with the parameter.
                                                                                                                                                                                                                                                                                        	ParameterKey *string
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          The TemplateParameter data type.

                                                                                                                                                                                                                                                                                          type TemplateStage

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

                                                                                                                                                                                                                                                                                            Enum values for TemplateStage

                                                                                                                                                                                                                                                                                            func (TemplateStage) Values

                                                                                                                                                                                                                                                                                            func (TemplateStage) Values() []TemplateStage

                                                                                                                                                                                                                                                                                              Values returns all known values for TemplateStage. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                              type TokenAlreadyExistsException

                                                                                                                                                                                                                                                                                              type TokenAlreadyExistsException struct {
                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                A client request token already exists.

                                                                                                                                                                                                                                                                                                func (*TokenAlreadyExistsException) Error

                                                                                                                                                                                                                                                                                                func (*TokenAlreadyExistsException) ErrorCode

                                                                                                                                                                                                                                                                                                func (e *TokenAlreadyExistsException) ErrorCode() string

                                                                                                                                                                                                                                                                                                func (*TokenAlreadyExistsException) ErrorFault

                                                                                                                                                                                                                                                                                                func (*TokenAlreadyExistsException) ErrorMessage

                                                                                                                                                                                                                                                                                                func (e *TokenAlreadyExistsException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                type TypeNotFoundException

                                                                                                                                                                                                                                                                                                type TypeNotFoundException struct {
                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  The specified type does not exist in the CloudFormation registry.

                                                                                                                                                                                                                                                                                                  func (*TypeNotFoundException) Error

                                                                                                                                                                                                                                                                                                  func (e *TypeNotFoundException) Error() string

                                                                                                                                                                                                                                                                                                  func (*TypeNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                  func (e *TypeNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                  func (*TypeNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                  func (e *TypeNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                  func (*TypeNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                  func (e *TypeNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                  type TypeSummary

                                                                                                                                                                                                                                                                                                  type TypeSummary struct {
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// 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
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The description of the type.
                                                                                                                                                                                                                                                                                                  	Description *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// When the current default version of the type was registered.
                                                                                                                                                                                                                                                                                                  	LastUpdated *time.Time
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The kind of type.
                                                                                                                                                                                                                                                                                                  	Type RegistryType
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the type.
                                                                                                                                                                                                                                                                                                  	TypeArn *string
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The name of the type.
                                                                                                                                                                                                                                                                                                  	TypeName *string
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    Contains summary information about the specified CloudFormation type.

                                                                                                                                                                                                                                                                                                    type TypeVersionSummary

                                                                                                                                                                                                                                                                                                    type TypeVersionSummary struct {
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the type version.
                                                                                                                                                                                                                                                                                                    	Arn *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The description of the type version.
                                                                                                                                                                                                                                                                                                    	Description *string
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// Whether the specified type version is set as the default version.
                                                                                                                                                                                                                                                                                                    	IsDefaultVersion *bool
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// When the version was registered.
                                                                                                                                                                                                                                                                                                    	TimeCreated *time.Time
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The kind of type.
                                                                                                                                                                                                                                                                                                    	Type RegistryType
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// The name of the type.
                                                                                                                                                                                                                                                                                                    	TypeName *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
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      Contains summary information about a specific version of a CloudFormation type.

                                                                                                                                                                                                                                                                                                      type Visibility

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

                                                                                                                                                                                                                                                                                                        Enum values for Visibility

                                                                                                                                                                                                                                                                                                        func (Visibility) Values

                                                                                                                                                                                                                                                                                                        func (Visibility) Values() []Visibility

                                                                                                                                                                                                                                                                                                          Values returns all known values for Visibility. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.