cloudformation

type CancelUpdateStackInput struct {
	// A unique identifier for this CancelUpdateStack request. Specify this token if
	// you plan to retry requests so that AWS CloudFormation knows that you're not
	// attempting to cancel an update on a stack with the same name. You might retry
	// CancelUpdateStack requests to ensure that AWS CloudFormation successfully
	// received them.
	ClientRequestToken *string
	// The name or the unique stack ID that is associated with the stack.
	StackName *string
}

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

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

type ContinueUpdateRollbackInput struct {
	// The name or the unique ID of the stack that you want to continue rolling back.
	// Don't specify the name of a nested stack (a stack that was created by using the
	// AWS::CloudFormation::Stack resource). Instead, use this operation on the parent
	// stack (the stack that contains the AWS::CloudFormation::Stack resource).
	StackName *string
	// The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that AWS CloudFormation assumes to roll back the stack. AWS CloudFormation
	// uses the role's credentials to make calls on your behalf. AWS CloudFormation
	// always uses this role for all future operations on the stack. As long as users
	// have permission to operate on the stack, AWS CloudFormation uses this role even
	// if the users don't have permission to pass it. Ensure that the role grants least
	// privilege. If you don't specify a value, AWS CloudFormation uses the role that
	// was previously associated with the stack. If no role is available, AWS
	// CloudFormation uses a temporary session that is generated from your user
	// credentials.
	RoleARN *string
	// A list of the logical IDs of the resources that AWS CloudFormation skips during
	// the continue update rollback operation. You can specify only resources that are
	// in the UPDATE_FAILED state because a rollback failed. You can't specify
	// resources that are in the UPDATE_FAILED state for other reasons, for example,
	// because an update was cancelled. To check why a resource update failed, use the
	// DescribeStackResources () action, and view the resource status reason. Specify
	// this property to skip rolling back resources that AWS CloudFormation can't
	// successfully roll back. We recommend that you  troubleshoot
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/troubleshooting.html#troubleshooting-errors-update-rollback-failed)
	// resources before skipping them. AWS CloudFormation sets the status of the
	// specified resources to UPDATE_COMPLETE and continues to roll back the stack.
	// After the rollback is complete, the state of the skipped resources will be
	// inconsistent with the state of the resources in the stack template. Before
	// performing another stack update, you must update the stack or resources to be
	// consistent with each other. If you don't, subsequent stack updates might fail,
	// and the stack will become unrecoverable. Specify the minimum number of resources
	// required to successfully roll back your stack. For example, a failed resource
	// update might cause dependent resources to fail. In this case, it might not be
	// necessary to skip the dependent resources. To skip resources that are part of
	// nested stacks, use the following format: NestedStackName.ResourceLogicalID. If
	// you want to specify the logical ID of a stack resource (Type:
	// AWS::CloudFormation::Stack) in the ResourcesToSkip list, then its corresponding
	// embedded stack must be in one of the following states: DELETE_IN_PROGRESS,
	// DELETE_COMPLETE, or DELETE_FAILED. Don't confuse a child stack's name with its
	// corresponding logical ID defined in the parent stack. For an example of a
	// continue update rollback operation with nested stacks, see Using ResourcesToSkip
	// to recover a nested stacks hierarchy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html#nested-stacks).
	ResourcesToSkip []*string
	// A unique identifier for this ContinueUpdateRollback request. Specify this token
	// if you plan to retry requests so that AWS CloudFormation knows that you're not
	// attempting to continue the rollback to a stack with the same name. You might
	// retry ContinueUpdateRollback requests to ensure that AWS CloudFormation
	// successfully received them.
	ClientRequestToken *string
}

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

type CreateChangeSetInput struct {
	// The resources to import into your stack.
	ResourcesToImport []*types.ResourceToImport
	// Key-value pairs to associate with this stack. AWS CloudFormation also propagates
	// these tags to resources in the stack. You can specify a maximum of 50 tags.
	Tags []*types.Tag
	// The rollback triggers for AWS CloudFormation to monitor during stack creation
	// and updating operations, and for the specified monitoring period afterwards.
	RollbackConfiguration *types.RollbackConfiguration
	// In some cases, you must explicitly acknowledge that your stack template contains
	// certain capabilities in order for AWS CloudFormation to create the stack.
	//
	//     *
	// CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack 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 those stacks,
	// you must explicitly acknowledge this by specifying one of these capabilities.
	// The following IAM resources require you to specify either the CAPABILITY_IAM or
	// CAPABILITY_NAMED_IAM capability.
	//
	//         * If you have IAM resources, you can
	// specify either capability.
	//
	//         * If you have IAM resources with custom
	// names, you must specify CAPABILITY_NAMED_IAM.
	//
	//         * If you don't specify
	// either of these capabilities, AWS CloudFormation returns an
	// InsufficientCapabilities error.
	//
	//     If your stack template contains these
	// resources, we recommend that you review all permissions associated with them and
	// edit their permissions if necessary.
	//
	//         * AWS::IAM::AccessKey
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html)
	//
	//
	// * AWS::IAM::Group
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html)
	//
	//
	// * AWS::IAM::InstanceProfile
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html)
	//
	//
	// * AWS::IAM::Policy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html)
	//
	//
	// * AWS::IAM::Role
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)
	//
	//
	// * AWS::IAM::User
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html)
	//
	//
	// * AWS::IAM::UserToGroupAddition
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html)
	//
	//
	// For more information, see Acknowledging IAM Resources in AWS CloudFormation
	// Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities).
	//
	//
	// * CAPABILITY_AUTO_EXPAND Some template contain macros. Macros perform custom
	// processing on templates; this can include simple actions like find-and-replace
	// operations, all the way to extensive transformations of entire templates.
	// Because of this, users typically create a change set from the processed
	// template, so that they can review the changes resulting from the macros before
	// actually creating the stack. If your stack template contains one or more macros,
	// and you choose to create a stack directly from the processed template, without
	// first reviewing the resulting changes in a change set, you must acknowledge this
	// capability. This includes the AWS::Include
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html)
	// and AWS::Serverless
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html)
	// transforms, which are macros hosted by AWS CloudFormation. This capacity does
	// not apply to creating change sets, and specifying it when creating change sets
	// has no effect. Also, change sets do not currently support nested stacks. If you
	// want to create a stack from a stack template that contains macros and nested
	// stacks, you must create or update the stack directly from the template using the
	// CreateStack () or UpdateStack () action, and specifying this capability. For
	// more information on macros, see Using AWS CloudFormation Macros to Perform
	// Custom Processing on Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html).
	Capabilities []types.Capability
	// The Amazon Resource Names (ARNs) of Amazon Simple Notification Service (Amazon
	// SNS) topics that AWS CloudFormation associates with the stack. To remove all
	// associated notification topics, specify an empty list.
	NotificationARNs []*string
	// The location of the file that contains the revised template. The URL must point
	// to a template (max size: 460,800 bytes) that is located in an S3 bucket. AWS
	// CloudFormation generates the change set by comparing this template with the
	// stack that you specified. Conditional: You must specify only TemplateBody or
	// TemplateURL.
	TemplateURL *string
	// The name of the change set. The name must be unique among all change sets that
	// are associated with the specified stack. A change set name can contain only
	// alphanumeric, case sensitive characters and hyphens. It must start with an
	// alphabetic character and cannot exceed 128 characters.
	ChangeSetName *string
	// The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that AWS CloudFormation assumes when executing the change set. AWS
	// CloudFormation uses the role's credentials to make calls on your behalf. AWS
	// CloudFormation uses this role for all future operations on the stack. As long as
	// users have permission to operate on the stack, AWS CloudFormation uses this role
	// even if the users don't have permission to pass it. Ensure that the role grants
	// least privilege. If you don't specify a value, AWS CloudFormation uses the role
	// that was previously associated with the stack. If no role is available, AWS
	// CloudFormation uses a temporary session that is generated from your user
	// credentials.
	RoleARN *string
	// A structure that contains the body of the revised template, with a minimum
	// length of 1 byte and a maximum length of 51,200 bytes. AWS CloudFormation
	// generates the change set by comparing this template with the template of the
	// stack that you specified. Conditional: You must specify only TemplateBody or
	// TemplateURL.
	TemplateBody *string
	// Whether to reuse the template that is associated with the stack to create the
	// change set.
	UsePreviousTemplate *bool
	// A list of Parameter structures that specify input parameters for the change set.
	// For more information, see the Parameter () data type.
	Parameters []*types.Parameter
	// The template resource types that you have permissions to work with if you
	// execute this change set, such as AWS::EC2::Instance, AWS::EC2::*, or
	// Custom::MyCustomInstance. If the list of resource types doesn't include a
	// resource type that you're updating, the stack update fails. By default, AWS
	// CloudFormation grants permissions to all resource types. AWS Identity and Access
	// Management (IAM) uses this parameter for condition keys in IAM policies for AWS
	// CloudFormation. For more information, see Controlling Access with AWS Identity
	// and Access Management
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html)
	// in the AWS CloudFormation User Guide.
	ResourceTypes []*string
	// A description to help you identify this change set.
	Description *string
	// The name or the unique ID of the stack for which you are creating a change set.
	// AWS CloudFormation generates the change set by comparing this stack's
	// information with the information that you submit, such as a modified template or
	// different parameter input values.
	StackName *string
	// A unique identifier for this CreateChangeSet request. Specify this token if you
	// plan to retry requests so that AWS CloudFormation knows that you're not
	// attempting to create another change set with the same name. You might retry
	// CreateChangeSet requests to ensure that AWS CloudFormation successfully received
	// them.
	ClientToken *string
	// The type of change set operation. To create a change set for a new stack,
	// specify CREATE. To create a change set for an existing stack, specify UPDATE. To
	// create a change set for an import operation, specify IMPORT. If you create a
	// change set for a new stack, AWS Cloudformation creates a stack with a unique
	// stack ID, but no template or resources. The stack will be in the
	// REVIEW_IN_PROGRESS
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html#d0e11995)
	// state until you execute the change set. By default, AWS CloudFormation specifies
	// UPDATE. You can't use the UPDATE type to create a change set for a new stack or
	// the CREATE type to create a change set for an existing stack.
	ChangeSetType types.ChangeSetType
}

type CreateChangeSetOutput struct {
	// The unique ID of the stack.
	StackId *string
	// The Amazon Resource Name (ARN) of the change set.
	Id *string

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

type CreateStackInput struct {
	// Structure containing the stack policy body. For more information, go to  Prevent
	// Updates to Stack Resources
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html)
	// in the AWS CloudFormation User Guide. You can specify either the StackPolicyBody
	// or the StackPolicyURL parameter, but not both.
	StackPolicyBody *string
	// Structure containing the template body with a minimum length of 1 byte and a
	// maximum length of 51,200 bytes. For more information, go to Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify either the
	// TemplateBody or the TemplateURL parameter, but not both.
	TemplateBody *string
	// The name that is associated with the stack. The name must be unique in the
	// Region in which you are creating the stack. A stack name can contain only
	// alphanumeric characters (case sensitive) and hyphens. It must start with an
	// alphabetic character and cannot be longer than 128 characters.
	StackName *string
	// Location of a file containing the stack policy. The URL must point to a policy
	// (maximum size: 16 KB) located in an S3 bucket in the same Region as the stack.
	// You can specify either the StackPolicyBody or the StackPolicyURL parameter, but
	// not both.
	StackPolicyURL *string
	// Determines what action will be taken if stack creation fails. This must be one
	// of: DO_NOTHING, ROLLBACK, or DELETE. You can specify either OnFailure or
	// DisableRollback, but not both. Default: ROLLBACK
	OnFailure types.OnFailure
	// The Simple Notification Service (SNS) topic ARNs to publish stack related
	// events. You can find your SNS topic ARNs using the SNS console or your Command
	// Line Interface (CLI).
	NotificationARNs []*string
	// In some cases, you must explicitly acknowledge that your stack template contains
	// certain capabilities in order for AWS CloudFormation to create the stack.
	//
	//     *
	// CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack 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 those stacks,
	// you must explicitly acknowledge this by specifying one of these capabilities.
	// The following IAM resources require you to specify either the CAPABILITY_IAM or
	// CAPABILITY_NAMED_IAM capability.
	//
	//         * If you have IAM resources, you can
	// specify either capability.
	//
	//         * If you have IAM resources with custom
	// names, you must specify CAPABILITY_NAMED_IAM.
	//
	//         * If you don't specify
	// either of these capabilities, AWS CloudFormation returns an
	// InsufficientCapabilities error.
	//
	//     If your stack template contains these
	// resources, we recommend that you review all permissions associated with them and
	// edit their permissions if necessary.
	//
	//         * AWS::IAM::AccessKey
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html)
	//
	//
	// * AWS::IAM::Group
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html)
	//
	//
	// * AWS::IAM::InstanceProfile
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html)
	//
	//
	// * AWS::IAM::Policy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html)
	//
	//
	// * AWS::IAM::Role
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)
	//
	//
	// * AWS::IAM::User
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html)
	//
	//
	// * AWS::IAM::UserToGroupAddition
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html)
	//
	//
	// For more information, see Acknowledging IAM Resources in AWS CloudFormation
	// Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities).
	//
	//
	// * CAPABILITY_AUTO_EXPAND Some template contain macros. Macros perform custom
	// processing on templates; this can include simple actions like find-and-replace
	// operations, all the way to extensive transformations of entire templates.
	// Because of this, users typically create a change set from the processed
	// template, so that they can review the changes resulting from the macros before
	// actually creating the stack. If your stack template contains one or more macros,
	// and you choose to create a stack directly from the processed template, without
	// first reviewing the resulting changes in a change set, you must acknowledge this
	// capability. This includes the AWS::Include
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html)
	// and AWS::Serverless
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html)
	// transforms, which are macros hosted by AWS CloudFormation. Change sets do not
	// currently support nested stacks. If you want to create a stack from a stack
	// template that contains macros and nested stacks, you must create the stack
	// directly from the template using this capability. You should only create stacks
	// directly from a stack template that contains macros if you know what processing
	// the macro performs. Each macro relies on an underlying Lambda service function
	// for processing stack templates. Be aware that the Lambda function owner can
	// update the function operation without AWS CloudFormation being notified. For
	// more information, see Using AWS CloudFormation Macros to Perform Custom
	// Processing on Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html).
	Capabilities []types.Capability
	// Whether to enable termination protection on the specified stack. If a user
	// attempts to delete a stack with termination protection enabled, the operation
	// fails and the stack remains unchanged. 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. Termination protection is disabled on
	// stacks by default. 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.
	EnableTerminationProtection *bool
	// The amount of time that can pass before the stack status becomes CREATE_FAILED;
	// if DisableRollback is not set or is set to false, the stack will be rolled back.
	TimeoutInMinutes *int32
	// Set to true to disable rollback of the stack if stack creation failed. You can
	// specify either DisableRollback or OnFailure, but not both. Default: false
	DisableRollback *bool
	// The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that AWS CloudFormation assumes to create the stack. AWS CloudFormation
	// uses the role's credentials to make calls on your behalf. AWS CloudFormation
	// always uses this role for all future operations on the stack. As long as users
	// have permission to operate on the stack, AWS CloudFormation uses this role even
	// if the users don't have permission to pass it. Ensure that the role grants least
	// privilege. If you don't specify a value, AWS CloudFormation uses the role that
	// was previously associated with the stack. If no role is available, AWS
	// CloudFormation uses a temporary session that is generated from your user
	// credentials.
	RoleARN *string
	// Key-value pairs to associate with this stack. AWS CloudFormation also propagates
	// these tags to the resources created in the stack. A maximum number of 50 tags
	// can be specified.
	Tags []*types.Tag
	// The rollback triggers for AWS CloudFormation to monitor during stack creation
	// and updating operations, and for the specified monitoring period afterwards.
	RollbackConfiguration *types.RollbackConfiguration
	// A list of Parameter structures that specify input parameters for the stack. For
	// more information, see the Parameter
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html)
	// data type.
	Parameters []*types.Parameter
	// The template resource types that you have permissions to work with for this
	// create stack action, such as AWS::EC2::Instance, AWS::EC2::*, or
	// Custom::MyCustomInstance. Use the following syntax to describe template resource
	// types: AWS::* (for all AWS resource), Custom::* (for all custom resources),
	// Custom::logical_ID  (for a specific custom resource), AWS::service_name::* (for
	// all resources of a particular AWS service), and
	// AWS::service_name::resource_logical_ID  (for a specific AWS resource). If the
	// list of resource types doesn't include a resource that you're creating, the
	// stack creation fails. By default, AWS CloudFormation grants permissions to all
	// resource types. AWS Identity and Access Management (IAM) uses this parameter for
	// AWS CloudFormation-specific condition keys in IAM policies. For more
	// information, see Controlling Access with AWS Identity and Access Management
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html).
	ResourceTypes []*string
	// A unique identifier for this CreateStack request. Specify this token if you plan
	// to retry requests so that AWS CloudFormation knows that you're not attempting to
	// create a stack with the same name. You might retry CreateStack requests to
	// ensure that AWS CloudFormation successfully received them. 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
	// Location of file containing the template body. The URL must point to a template
	// (max size: 460,800 bytes) that is located in an Amazon S3 bucket. For more
	// information, go to the Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify either the
	// TemplateBody or the TemplateURL parameter, but not both.
	TemplateURL *string
}

type CreateStackInstancesInput struct {
	// The names of one or more Regions where you want to create stack instances using
	// the specified AWS account(s).
	Regions []*string
	// The name or unique ID of the stack set that you want to create stack instances
	// from.
	StackSetName *string
	// The unique identifier for this stack set operation. The operation ID also
	// functions as an idempotency token, to ensure that AWS CloudFormation performs
	// the stack set operation only once, even if you retry the request multiple times.
	// You might retry stack set operation requests to ensure that AWS CloudFormation
	// successfully received them. If you don't specify an operation ID, the SDK
	// generates one automatically. Repeating this stack set operation with a new
	// operation ID retries all stack instances whose status is OUTDATED.
	OperationId *string
	// [Self-managed permissions] The names of one or more AWS accounts that you want
	// to create stack instances in the specified Region(s) for. You can specify
	// Accounts or DeploymentTargets, but not both.
	Accounts []*string
	// [Service-managed permissions] The AWS Organizations accounts for which to create
	// stack instances in the specified Regions. You can specify Accounts or
	// DeploymentTargets, but not both.
	DeploymentTargets *types.DeploymentTargets
	// Preferences for how AWS CloudFormation performs this stack set operation.
	OperationPreferences *types.StackSetOperationPreferences
	// A list of stack set parameters whose values you want to override in the selected
	// stack instances. Any overridden parameter values will be applied to all stack
	// instances in the specified accounts and Regions. When specifying parameters and
	// their values, be aware of how AWS CloudFormation sets parameter values during
	// stack instance operations:
	//
	//     * To override the current value for a parameter,
	// include the parameter and specify its value.
	//
	//     * To leave a parameter set to
	// its present value, you can do one of the following:
	//
	//         * Do not include
	// the parameter in the list.
	//
	//         * Include the parameter and specify
	// UsePreviousValue as true. (You cannot specify both a value and set
	// UsePreviousValue to true.)
	//
	//     * To set all overridden parameter back to the
	// values specified in the stack set, specify a parameter list but do not include
	// any parameters.
	//
	//     * To leave all parameters set to their present values, do
	// not specify this property at all.
	//
	// During stack set updates, any parameter
	// values overridden for a stack instance are not updated, but retain their
	// overridden value. You can only override the parameter values that are specified
	// in the stack set; to add or delete a parameter itself, use UpdateStackSet
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html)
	// to update the stack set template.
	ParameterOverrides []*types.Parameter
}

type CreateStackInstancesOutput struct {
	// The unique identifier for this stack set operation.
	OperationId *string

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

type CreateStackOutput struct {
	// Unique identifier of the stack.
	StackId *string

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

type CreateStackSetInput struct {
	// The structure that contains the template body, with a minimum length of 1 byte
	// and a maximum length of 51,200 bytes. For more information, see Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify either the
	// TemplateBody or the TemplateURL parameter, but not both.
	TemplateBody *string
	// The name of the IAM execution role to use to create the stack set. If you do not
	// specify an execution role, AWS CloudFormation uses the
	// AWSCloudFormationStackSetExecutionRole role for the stack set operation. Specify
	// an IAM role only if you are using customized execution roles to control which
	// stack resources users and groups can include in their stack sets.  </p>
	ExecutionRoleName *string
	// The Amazon Resource Number (ARN) of the IAM role to use to create this stack
	// set. Specify an IAM role only if you are using 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
	// Describes whether StackSets automatically deploys to AWS Organizations accounts
	// that are added to the target organization or organizational unit (OU). Specify
	// only if PermissionModel is SERVICE_MANAGED.
	AutoDeployment *types.AutoDeployment
	// The name to associate with the stack set. The name must be unique in the Region
	// where you create your stack set. A stack name can contain only alphanumeric
	// characters (case-sensitive) and hyphens. It must start with an alphabetic
	// character and can't be longer than 128 characters.
	StackSetName *string
	// The input parameters for the stack set template.
	Parameters []*types.Parameter
	// A description of the stack set. You can use the description to identify the
	// stack set's purpose or other important information.
	Description *string
	// The key-value pairs to associate with this stack set and the stacks created from
	// it. AWS CloudFormation also propagates these tags to supported resources that
	// are created in the stacks. A maximum number of 50 tags can be specified. If you
	// specify tags as part of a CreateStackSet action, AWS CloudFormation checks to
	// see if you have the required IAM permission to tag resources. If you don't, the
	// entire CreateStackSet action fails with an access denied error, and the stack
	// set is not created.
	Tags []*types.Tag
	// The location of the file that contains the template body. The URL must point to
	// a template (maximum size: 460,800 bytes) that's located in an Amazon S3 bucket.
	// For more information, see Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify either the
	// TemplateBody or the TemplateURL parameter, but not both.
	TemplateURL *string
	// A unique identifier for this CreateStackSet request. Specify this token if you
	// plan to retry requests so that AWS CloudFormation knows that you're not
	// attempting to create another stack set with the same name. You might retry
	// CreateStackSet requests to ensure that AWS CloudFormation successfully received
	// them. If you don't specify an operation ID, the SDK generates one automatically.
	ClientRequestToken *string
	// In some cases, you must explicitly acknowledge that your stack set template
	// contains certain capabilities in order for AWS CloudFormation to create the
	// stack set and related stack instances.
	//
	//     * CAPABILITY_IAM and
	// CAPABILITY_NAMED_IAM Some stack 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 those stack sets, you must
	// explicitly acknowledge this by specifying one of these capabilities. The
	// following IAM resources require you to specify either the CAPABILITY_IAM or
	// CAPABILITY_NAMED_IAM capability.
	//
	//         * If you have IAM resources, you can
	// specify either capability.
	//
	//         * If you have IAM resources with custom
	// names, you must specify CAPABILITY_NAMED_IAM.
	//
	//         * If you don't specify
	// either of these capabilities, AWS CloudFormation returns an
	// InsufficientCapabilities error.
	//
	//     If your stack template contains these
	// resources, we recommend that you review all permissions associated with them and
	// edit their permissions if necessary.
	//
	//         * AWS::IAM::AccessKey
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html)
	//
	//
	// * AWS::IAM::Group
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html)
	//
	//
	// * AWS::IAM::InstanceProfile
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html)
	//
	//
	// * AWS::IAM::Policy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html)
	//
	//
	// * AWS::IAM::Role
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)
	//
	//
	// * AWS::IAM::User
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html)
	//
	//
	// * AWS::IAM::UserToGroupAddition
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html)
	//
	//
	// For more information, see Acknowledging IAM Resources in AWS CloudFormation
	// Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities).
	//
	//
	// * CAPABILITY_AUTO_EXPAND Some templates contain macros. If your stack template
	// contains one or more macros, and you choose to create a stack directly from the
	// processed template, without first reviewing the resulting changes in a change
	// set, you must acknowledge this capability. For more information, see Using AWS
	// CloudFormation Macros to Perform Custom Processing on Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html).
	// Stack sets do not currently support macros in stack templates. (This includes
	// the AWS::Include
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html)
	// and AWS::Serverless
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html)
	// transforms, which are macros hosted by AWS CloudFormation.) Even if you specify
	// this capability, if you include a macro in your template the stack set operation
	// will fail.
	Capabilities []types.Capability
	// Describes how the IAM roles required for stack set operations are created. By
	// default, SELF-MANAGED is specified.
	//
	//     * 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 types.PermissionModels
}

type CreateStackSetOutput struct {
	// The ID of the stack set that you're creating.
	StackSetId *string

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

type DeleteChangeSetInput struct {
	// The name or Amazon Resource Name (ARN) of the change set that you want to
	// delete.
	ChangeSetName *string
	// If you specified the name of a change set to delete, specify the stack name or
	// ID (ARN) that is associated with it.
	StackName *string
}

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

type DeleteStackInput struct {
	// A unique identifier for this DeleteStack request. Specify this token if you plan
	// to retry requests so that AWS CloudFormation knows that you're not attempting to
	// delete a stack with the same name. You might retry DeleteStack requests to
	// ensure that AWS CloudFormation successfully received them. 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 Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that AWS CloudFormation assumes to delete the stack. AWS CloudFormation
	// uses the role's credentials to make calls on your behalf. If you don't specify a
	// value, AWS CloudFormation uses the role that was previously associated with the
	// stack. If no role is available, AWS CloudFormation uses a temporary session that
	// is generated from your user credentials.
	RoleARN *string
	// For stacks in the DELETE_FAILED state, a list of resource logical IDs that are
	// associated with the resources you want to retain. During deletion, AWS
	// CloudFormation deletes the stack but does not delete the retained resources.
	// Retaining resources is useful when you cannot delete a resource, such as a
	// non-empty S3 bucket, but you want to delete the stack.
	RetainResources []*string
	// The name or the unique stack ID that is associated with the stack.
	StackName *string
}

type DeleteStackInstancesInput struct {
	// The name or unique ID of the stack set that you want to delete stack instances
	// for.
	StackSetName *string
	// The Regions where you want to delete stack set instances.
	Regions []*string
	// [Self-managed permissions] The names of the AWS accounts that you want to delete
	// stack instances for. You can specify Accounts or DeploymentTargets, but not
	// both.
	Accounts []*string
	// Removes 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. For more information, see Stack set operation options
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html#stackset-ops-options).
	RetainStacks *bool
	// Preferences for how AWS CloudFormation performs this stack set operation.
	OperationPreferences *types.StackSetOperationPreferences
	// [Service-managed permissions] The AWS Organizations accounts from which to
	// delete stack instances. You can specify Accounts or DeploymentTargets, but not
	// both.
	DeploymentTargets *types.DeploymentTargets
	// The unique identifier for this stack set operation. If you don't specify an
	// operation ID, the SDK generates one automatically. The operation ID also
	// functions as an idempotency token, to ensure that AWS CloudFormation performs
	// the stack set operation only once, even if you retry the request multiple times.
	// You can retry stack set operation requests to ensure that AWS CloudFormation
	// successfully received them. Repeating this stack set operation with a new
	// operation ID retries all stack instances whose status is OUTDATED.
	OperationId *string
}

type DeleteStackInstancesOutput struct {
	// The unique identifier for this stack set operation.
	OperationId *string

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

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

type DeleteStackSetInput struct {
	// The name or unique ID of the stack set that you're deleting. You can obtain this
	// value by running ListStackSets ().
	StackSetName *string
}

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

type DeregisterTypeInput struct {
	// The Amazon Resource Name (ARN) of the type. Conditional: You must specify either
	// TypeName and Type, or Arn.
	Arn *string
	// The name of the type. Conditional: You must specify either TypeName and Type, or
	// Arn.
	TypeName *string
	// The kind of type. Currently the only valid value is RESOURCE. Conditional: You
	// must specify either TypeName and Type, or Arn.
	Type types.RegistryType
	// 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
}

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

type DescribeAccountLimitsInput struct {
	// A string that identifies the next page of limits that you want to retrieve.
	NextToken *string
}

type DescribeAccountLimitsOutput struct {
	// If the output exceeds 1 MB in size, a string that identifies the next page of
	// limits. If no additional page exists, this value is null.
	NextToken *string
	// An account limit structure that contain a list of AWS CloudFormation account
	// limits and their values.
	AccountLimits []*types.AccountLimit

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

type DescribeChangeSetInput struct {
	// The name or Amazon Resource Name (ARN) of the change set that you want to
	// describe.
	ChangeSetName *string
	// If you specified the name of a change set, specify the stack name or ID (ARN) of
	// the change set you want to describe.
	StackName *string
	// A string (provided by the DescribeChangeSet () response output) that identifies
	// the next page of information that you want to retrieve.
	NextToken *string
}

type DescribeChangeSetOutput struct {
	// A list of Parameter structures that describes the input parameters and their
	// values used to create the change set. For more information, see the Parameter
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html)
	// data type.
	Parameters []*types.Parameter
	// A list of Change structures that describes the resources AWS CloudFormation
	// changes if you execute the change set.
	Changes []*types.Change
	// The current status of the change set, such as CREATE_IN_PROGRESS,
	// CREATE_COMPLETE, or FAILED.
	Status types.ChangeSetStatus
	// The name of the stack that is associated with the change set.
	StackName *string
	// The ARN of the stack that is associated with the change set.
	StackId *string
	// The start time when the change set was created, in UTC.
	CreationTime *time.Time
	// Information about the change set.
	Description *string
	// If you execute the change set, the list of capabilities that were explicitly
	// acknowledged when the change set was created.
	Capabilities []types.Capability
	// If you execute the change set, the tags that will be associated with the stack.
	Tags []*types.Tag
	// The rollback triggers for AWS CloudFormation to monitor during stack creation
	// and updating operations, and for the specified monitoring period afterwards.
	RollbackConfiguration *types.RollbackConfiguration
	// The name of the change set.
	ChangeSetName *string
	// A description of the change set's status. For example, if your attempt to create
	// a change set failed, AWS CloudFormation shows the error message.
	StatusReason *string
	// If the output exceeds 1 MB, a string that identifies the next page of changes.
	// If there is no additional page, this value is null.
	NextToken *string
	// The ARNs of the Amazon Simple Notification Service (Amazon SNS) topics that will
	// be associated with the stack if you execute the change set.
	NotificationARNs []*string
	// The ARN of the change set.
	ChangeSetId *string
	// If the change set execution status is AVAILABLE, you can execute the change set.
	// If you can’t execute the change set, the status indicates why. For example, a
	// change set might be in an UNAVAILABLE state because AWS CloudFormation is still
	// creating it or in an OBSOLETE state because the stack was already updated.
	ExecutionStatus types.ExecutionStatus

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

type DescribeStackDriftDetectionStatusInput struct {
	// The ID of the drift detection results of this operation. AWS CloudFormation
	// generates new results, with a new drift detection ID, each time this operation
	// is run. However, the number of drift results AWS CloudFormation retains for any
	// given stack, and for how long, may vary.
	StackDriftDetectionId *string
}

type DescribeStackDriftDetectionStatusOutput struct {
	// Time at which the stack drift detection operation was initiated.
	Timestamp *time.Time
	// The status of the stack drift detection operation.
	//
	//     * DETECTION_COMPLETE:
	// The stack drift detection operation has successfully completed for all resources
	// in the stack that support drift detection. (Resources that do not currently
	// support stack detection remain unchecked.) If you specified logical resource IDs
	// for AWS CloudFormation to use as a filter for the stack drift detection
	// operation, only the resources with those logical IDs are checked for drift.
	//
	//
	// * DETECTION_FAILED: The stack drift detection operation has failed for at least
	// one resource in the stack. Results will be available for resources on which AWS
	// CloudFormation successfully completed drift detection.
	//
	//     *
	// DETECTION_IN_PROGRESS: The stack drift detection operation is currently in
	// progress.
	DetectionStatus types.StackDriftDetectionStatus
	// The ID of the stack.
	StackId *string
	// Status of the stack's actual configuration compared to its expected
	// 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.
	StackDriftStatus types.StackDriftStatus
	// The ID of the drift detection results of this operation. AWS CloudFormation
	// generates new results, with a new drift detection ID, each time this operation
	// is run. However, the number of reports AWS CloudFormation retains for any given
	// stack, and for how long, may vary.
	StackDriftDetectionId *string
	// Total number of stack resources that have drifted. This is NULL until the drift
	// detection operation reaches a status of DETECTION_COMPLETE. This value will be 0
	// for stacks whose drift status is IN_SYNC.
	DriftedStackResourceCount *int32
	// The reason the stack drift detection operation has its current status.
	DetectionStatusReason *string

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

type DescribeStackEventsInput struct {
	// A string that identifies the next page of events that you want to retrieve.
	NextToken *string
	// The name or the unique stack ID that is associated with the stack, which are not
	// always interchangeable:
	//
	//     * Running stacks: You can specify either the
	// stack's name or its unique stack ID.
	//
	//     * Deleted stacks: You must specify the
	// unique stack ID.
	//
	// Default: There is no default value.
	StackName *string
}

type DescribeStackEventsOutput struct {
	// If the output exceeds 1 MB in size, a string that identifies the next page of
	// events. If no additional page exists, this value is null.
	NextToken *string
	// A list of StackEvents structures.
	StackEvents []*types.StackEvent

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

type DescribeStackInstanceInput struct {
	// The name or the unique stack ID of the stack set that you want to get stack
	// instance information for.
	StackSetName *string
	// The ID of an AWS account that's associated with this stack instance.
	StackInstanceAccount *string
	// The name of a Region that's associated with this stack instance.
	StackInstanceRegion *string
}

type DescribeStackInstanceOutput struct {
	// The stack instance that matches the specified request parameters.
	StackInstance *types.StackInstance

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

type DescribeStackResourceDriftsInput struct {
	// The resource drift status values to use as filters for the resource drift
	// results returned.
	//
	//     * DELETED: The resource differs from its expected
	// template configuration in that the resource has been deleted.
	//
	//     * MODIFIED:
	// One or more resource properties differ from their expected template values.
	//
	//
	// * IN_SYNC: The resources's actual configuration matches its expected template
	// configuration.
	//
	//     * NOT_CHECKED: AWS CloudFormation does not currently return
	// this value.
	StackResourceDriftStatusFilters []types.StackResourceDriftStatus
	// A string that identifies the next page of stack resource drift results.
	NextToken *string
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
	// The name of the stack for which you want drift information.
	StackName *string
}

type DescribeStackResourceDriftsOutput struct {
	// Drift information for the resources that have been checked for drift in the
	// specified stack. This includes actual and expected configuration values for
	// resources where AWS CloudFormation detects drift. For a given stack, there will
	// be one StackResourceDrift for each stack resource that has been checked for
	// drift. Resources that have not yet been checked for drift are not included.
	// Resources that do not currently support drift detection are not checked, and so
	// not included. For a list of resources that support drift detection, see
	// Resources that Support Drift Detection
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html).
	StackResourceDrifts []*types.StackResourceDrift
	// If the request doesn't return all of the remaining results, NextToken is set to
	// a token. To retrieve the next set of results, call DescribeStackResourceDrifts
	// again and assign that token to the request object's NextToken parameter. If the
	// request returns all results, NextToken is set to null.
	NextToken *string

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

type DescribeStackResourceInput struct {
	// The logical name of the resource as specified in the template. Default: There is
	// no default value.
	LogicalResourceId *string
	// The name or the unique stack ID that is associated with the stack, which are not
	// always interchangeable:
	//
	//     * Running stacks: You can specify either the
	// stack's name or its unique stack ID.
	//
	//     * Deleted stacks: You must specify the
	// unique stack ID.
	//
	// Default: There is no default value.
	StackName *string
}

type DescribeStackResourceOutput struct {
	// A StackResourceDetail structure containing the description of the specified
	// resource in the specified stack.
	StackResourceDetail *types.StackResourceDetail

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

type DescribeStackResourcesInput struct {
	// The name or unique identifier that corresponds to a physical instance ID of a
	// resource supported by AWS CloudFormation. For example, for an Amazon Elastic
	// Compute Cloud (EC2) instance, PhysicalResourceId corresponds to the InstanceId.
	// You can pass the EC2 InstanceId to DescribeStackResources to find which stack
	// the instance belongs to and what other resources are part of the stack.
	// Required: Conditional. If you do not specify PhysicalResourceId, you must
	// specify StackName. Default: There is no default value.
	PhysicalResourceId *string
	// The logical name of the resource as specified in the template. Default: There is
	// no default value.
	LogicalResourceId *string
	// The name or the unique stack ID that is associated with the stack, which are not
	// always interchangeable:
	//
	//     * Running stacks: You can specify either the
	// stack's name or its unique stack ID.
	//
	//     * Deleted stacks: You must specify the
	// unique stack ID.
	//
	// Default: There is no default value. Required: Conditional. If
	// you do not specify StackName, you must specify PhysicalResourceId.
	StackName *string
}

type DescribeStackResourcesOutput struct {
	// A list of StackResource structures.
	StackResources []*types.StackResource

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

type DescribeStackSetInput struct {
	// The name or unique ID of the stack set whose description you want.
	StackSetName *string
}

type DescribeStackSetOperationInput struct {
	// The unique ID of the stack set operation.
	OperationId *string
	// The name or the unique stack ID of the stack set for the stack operation.
	StackSetName *string
}

type DescribeStackSetOperationOutput struct {
	// The specified stack set operation.
	StackSetOperation *types.StackSetOperation

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

type DescribeStackSetOutput struct {
	// The specified stack set.
	StackSet *types.StackSet

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

type DescribeStacksInput struct {
	// The name or the unique stack ID that is associated with the stack, which are not
	// always interchangeable:
	//
	//     * Running stacks: You can specify either the
	// stack's name or its unique stack ID.
	//
	//     * Deleted stacks: You must specify the
	// unique stack ID.
	//
	// Default: There is no default value.
	StackName *string
	// A string that identifies the next page of stacks that you want to retrieve.
	NextToken *string
}

type DescribeStacksOutput struct {
	// If the output exceeds 1 MB in size, a string that identifies the next page of
	// stacks. If no additional page exists, this value is null.
	NextToken *string
	// A list of stack structures.
	Stacks []*types.Stack

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

type DescribeTypeInput struct {
	// The name of the type. Conditional: You must specify either TypeName and Type, or
	// Arn.
	TypeName *string
	// The Amazon Resource Name (ARN) of the type. Conditional: You must specify either
	// TypeName and Type, or Arn.
	Arn *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. If you specify a VersionId, DescribeType returns information about
	// that specific type version. Otherwise, it returns information about the default
	// type version.
	VersionId *string
	// The kind of type. Currently the only valid value is RESOURCE. Conditional: You
	// must specify either TypeName and Type, or Arn.
	Type types.RegistryType
}

type DescribeTypeOutput struct {
	// The deprecation status of the type. Valid values include:
	//
	//     * LIVE: The type
	// is registered and can be used in CloudFormation operations, dependent on its
	// provisioning behavior and visibility scope.
	//
	//     * DEPRECATED: The type has been
	// deregistered and can no longer be used in CloudFormation operations.
	DeprecatedStatus types.DeprecatedStatus
	// The URL of the source code for the type.
	SourceUrl *string
	// The description of the registered type.
	Description *string
	// The Amazon Resource Name (ARN) of the type.
	Arn *string
	// The URL of a page providing detailed documentation for this type.
	DocumentationUrl *string
	// The name of the registered type.
	TypeName *string
	// The schema that defines the type. For more information on type schemas, see
	// Resource Provider Schema
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-schema.html)
	// in the CloudFormation CLI User Guide.
	Schema *string
	// When the specified type version was registered.
	LastUpdated *time.Time
	// The kind of type. Currently the only valid value is RESOURCE.
	Type types.RegistryType
	// When the specified type version was registered.
	TimeCreated *time.Time
	// The provisioning behavior of the type. AWS CloudFormation determines the
	// provisioning type during registration, based on the types of handlers in the
	// schema handler package submitted. Valid values include:
	//
	//     * FULLY_MUTABLE:
	// The type includes an update handler to process updates to the type during stack
	// update operations.
	//
	//     * IMMUTABLE: The type does not include an update
	// handler, so the type cannot be updated and must instead be replaced during stack
	// update operations.
	//
	//     * NON_PROVISIONABLE: The type does not include all of
	// the following handlers, and therefore cannot actually be provisioned.
	//
	//         *
	// create
	//
	//         * read
	//
	//         * delete
	ProvisioningType types.ProvisioningType
	// The Amazon Resource Name (ARN) of the IAM execution role used to register the
	// type. If your resource type calls AWS APIs in any of its handlers, you must
	// create an IAM execution role
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) that includes
	// the necessary permissions to call those AWS APIs, and provision that execution
	// role in your account. CloudFormation then assumes that execution role to provide
	// your resource type with the appropriate credentials.
	ExecutionRoleArn *string
	// The scope at which the type is visible and usable in CloudFormation operations.
	// Valid values include:
	//
	//     * PRIVATE: The type is only visible and usable within
	// the account in which it is registered. Currently, AWS CloudFormation marks any
	// types you register as PRIVATE.
	//
	//     * PUBLIC: The type is publically visible and
	// usable within any Amazon account.
	Visibility types.Visibility
	// Contains logging configuration information for a type.
	LoggingConfig *types.LoggingConfig
	// Whether the specified type version is set as the default version.
	IsDefaultVersion *bool
	// 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

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

type DescribeTypeRegistrationInput struct {
	// The identifier for this registration request. This registration token is
	// generated by CloudFormation when you initiate a registration request using
	// RegisterType ().
	RegistrationToken *string
}

type DescribeTypeRegistrationOutput struct {
	// The description of the type registration request.
	Description *string
	// The current status of the type registration request.
	ProgressStatus types.RegistrationStatus
	// The Amazon Resource Name (ARN) of this specific version of the type being
	// registered. For registration requests with a ProgressStatus of other than
	// COMPLETE, this will be null.
	TypeVersionArn *string
	// The Amazon Resource Name (ARN) of the type being registered. For registration
	// requests with a ProgressStatus of other than COMPLETE, this will be null.
	TypeArn *string

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

type DetectStackDriftInput struct {
	// The logical names of any resources you want to use as filters.
	LogicalResourceIds []*string
	// The name of the stack for which you want to detect drift.
	StackName *string
}

type DetectStackDriftOutput struct {
	// The ID of the drift detection results of this operation. AWS CloudFormation
	// generates new results, with a new drift detection ID, each time this operation
	// is run. However, the number of drift results AWS CloudFormation retains for any
	// given stack, and for how long, may vary.
	StackDriftDetectionId *string

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

type DetectStackResourceDriftInput struct {
	// The name of the stack to which the resource belongs.
	StackName *string
	// The logical name of the resource for which to return drift information.
	LogicalResourceId *string
}

type DetectStackResourceDriftOutput struct {
	// Information about whether the resource's actual configuration has drifted from
	// its expected template configuration, including actual and expected property
	// values and any differences detected.
	StackResourceDrift *types.StackResourceDrift

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

type DetectStackSetDriftInput struct {
	// The name of the stack set on which to perform the drift detection operation.
	StackSetName *string
	// The ID of the stack set operation.
	OperationId *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).
	OperationPreferences *types.StackSetOperationPreferences
}

type DetectStackSetDriftOutput struct {
	// The ID of the drift detection stack set operation. you can use this operation id
	// with DescribeStackSetOperation () to monitor the progress of the drift detection
	// operation.
	OperationId *string

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

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

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

type EstimateTemplateCostInput struct {
	// A list of Parameter structures that specify input parameters.
	Parameters []*types.Parameter
	// Structure containing the template body with a minimum length of 1 byte and a
	// maximum length of 51,200 bytes. (For more information, go to Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide.) Conditional: You must pass TemplateBody
	// or TemplateURL. If both are passed, only TemplateBody is used.
	TemplateBody *string
	// Location of file containing the template body. The URL must point to a template
	// that is located in an Amazon S3 bucket. For more information, go to Template
	// Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must pass TemplateURL or
	// TemplateBody. If both are passed, only TemplateBody is used.
	TemplateURL *string
}

type EstimateTemplateCostOutput struct {
	// An AWS Simple Monthly Calculator URL with a query string that describes the
	// resources required to run the template.
	Url *string

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

type ExecuteChangeSetInput struct {
	// A unique identifier for this ExecuteChangeSet request. Specify this token if you
	// plan to retry requests so that AWS CloudFormation knows that you're not
	// attempting to execute a change set to update a stack with the same name. You
	// might retry ExecuteChangeSet requests to ensure that AWS CloudFormation
	// successfully received them.
	ClientRequestToken *string
	// If you specified the name of a change set, specify the stack name or ID (ARN)
	// that is associated with the change set you want to execute.
	StackName *string
	// The name or ARN of the change set that you want use to update the specified
	// stack.
	ChangeSetName *string
}

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

type GetStackPolicyInput struct {
	// The name or unique stack ID that is associated with the stack whose policy you
	// want to get.
	StackName *string
}

type GetStackPolicyOutput struct {
	// Structure containing the stack policy body. (For more information, go to
	// Prevent Updates to Stack Resources
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html)
	// in the AWS CloudFormation User Guide.)
	StackPolicyBody *string

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

type GetTemplateInput struct {
	// The name or the unique stack ID that is associated with the stack, which are not
	// always interchangeable:
	//
	//     * Running stacks: You can specify either the
	// stack's name or its unique stack ID.
	//
	//     * Deleted stacks: You must specify the
	// unique stack ID.
	//
	// Default: There is no default value.
	StackName *string
	// For templates that include transforms, the stage of the template that AWS
	// CloudFormation returns. To get the user-submitted template, specify Original. To
	// get the template after AWS CloudFormation has processed all transforms, specify
	// Processed. If the template doesn't include transforms, Original and Processed
	// return the same template. By default, AWS CloudFormation specifies Original.
	TemplateStage types.TemplateStage
	// The name or Amazon Resource Name (ARN) of a change set for which AWS
	// CloudFormation returns the associated template. If you specify a name, you must
	// also specify the StackName.
	ChangeSetName *string
}

type GetTemplateOutput struct {
	// Structure containing the template body. (For more information, go to Template
	// Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide.) AWS CloudFormation returns the same
	// template that was used when the stack was created.
	TemplateBody *string
	// The stage of the template that you can retrieve. For stacks, the Original and
	// Processed templates are always available. For change sets, the Original template
	// is always available. After AWS CloudFormation finishes creating the change set,
	// the Processed template becomes available.
	StagesAvailable []types.TemplateStage

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

type GetTemplateSummaryInput struct {
	// Structure containing the template body with a minimum length of 1 byte and a
	// maximum length of 51,200 bytes. For more information about templates, see
	// Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify only one of
	// the following parameters: StackName, StackSetName, TemplateBody, or TemplateURL.
	TemplateBody *string
	// Location of file containing the template body. The URL must point to a template
	// (max size: 460,800 bytes) that is located in an Amazon S3 bucket. For more
	// information about templates, see Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify only one of
	// the following parameters: StackName, StackSetName, TemplateBody, or TemplateURL.
	TemplateURL *string
	// The name or unique ID of the stack set from which the stack was created.
	// Conditional: You must specify only one of the following parameters: StackName,
	// StackSetName, TemplateBody, or TemplateURL.
	StackSetName *string
	// The name or the stack ID that is associated with the stack, which are not always
	// interchangeable. For running stacks, you can specify either the stack's name or
	// its unique stack ID. For deleted stack, you must specify the unique stack ID.
	// Conditional: You must specify only one of the following parameters: StackName,
	// StackSetName, TemplateBody, or TemplateURL.
	StackName *string
}

type GetTemplateSummaryOutput struct {
	// A list of resource identifier summaries that describe the target resources of an
	// import operation and the properties you can provide during the import to
	// identify the target resources. For example, BucketName is a possible identifier
	// property for an AWS::S3::Bucket resource.
	ResourceIdentifierSummaries []*types.ResourceIdentifierSummary
	// The AWS template format version, which identifies the capabilities of the
	// template.
	Version *string
	// The value that is defined for the Metadata property of the template.
	Metadata *string
	// The value that is defined in the Description property of the template.
	Description *string
	// A list of the transforms that are declared in the template.
	DeclaredTransforms []*string
	// A list of all the template resource types that are defined in the template, such
	// as AWS::EC2::Instance, AWS::Dynamo::Table, and Custom::MyCustomInstance.
	ResourceTypes []*string
	// The capabilities found within the template. If your template contains IAM
	// resources, you must specify the CAPABILITY_IAM or CAPABILITY_NAMED_IAM value for
	// this parameter when you use the CreateStack () or UpdateStack () actions with
	// your template; otherwise, those actions return an InsufficientCapabilities
	// error. 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 []types.Capability
	// The list of resources that generated the values in the Capabilities response
	// element.
	CapabilitiesReason *string
	// A list of parameter declarations that describe various properties for each
	// parameter.
	Parameters []*types.ParameterDeclaration

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

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type IdempotencyTokenProvider interface {
	GetIdempotencyToken() (string, error)
}

type ListChangeSetsInput struct {
	// A string (provided by the ListChangeSets () response output) that identifies the
	// next page of change sets that you want to retrieve.
	NextToken *string
	// The name or the Amazon Resource Name (ARN) of the stack for which you want to
	// list change sets.
	StackName *string
}

type ListChangeSetsOutput struct {
	// If the output exceeds 1 MB, a string that identifies the next page of change
	// sets. If there is no additional page, this value is null.
	NextToken *string
	// A list of ChangeSetSummary structures that provides the ID and status of each
	// change set for the specified stack.
	Summaries []*types.ChangeSetSummary

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

type ListExportsInput struct {
	// A string (provided by the ListExports () response output) that identifies the
	// next page of exported output values that you asked to retrieve.
	NextToken *string
}

type ListExportsOutput struct {
	// The output for the ListExports () action.
	Exports []*types.Export
	// If the output exceeds 100 exported output values, a string that identifies the
	// next page of exports. If there is no additional page, this value is null.
	NextToken *string

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

type ListImportsInput struct {
	// The name of the exported output value. AWS CloudFormation returns the stack
	// names that are importing this value.
	ExportName *string
	// A string (provided by the ListImports () response output) that identifies the
	// next page of stacks that are importing the specified exported output value.
	NextToken *string
}

type ListImportsOutput struct {
	// A string that identifies the next page of exports. If there is no additional
	// page, this value is null.
	NextToken *string
	// A list of stack names that are importing the specified exported output value.
	Imports []*string

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

type ListStackInstancesInput struct {
	// The name of the AWS account that you want to list stack instances for.
	StackInstanceAccount *string
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
	// The status that stack instances are filtered by.
	Filters []*types.StackInstanceFilter
	// If the previous request didn't return all of the remaining results, the
	// response's NextToken parameter value is set to a token. To retrieve the next set
	// of results, call ListStackInstances again and assign that token to the request
	// object's NextToken parameter. If there are no remaining results, the previous
	// response object's NextToken parameter is set to null.
	NextToken *string
	// The name of the Region where you want to list stack instances.
	StackInstanceRegion *string
	// The name or unique ID of the stack set that you want to list stack instances
	// for.
	StackSetName *string
}

type ListStackInstancesOutput struct {
	// If the request doesn't return all of the remaining results, NextToken is set to
	// a token. To retrieve the next set of results, call ListStackInstances again and
	// assign that token to the request object's NextToken parameter. If the request
	// returns all results, NextToken is set to null.
	NextToken *string
	// A list of StackInstanceSummary structures that contain information about the
	// specified stack instances.
	Summaries []*types.StackInstanceSummary

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

type ListStackResourcesInput struct {
	// A string that identifies the next page of stack resources that you want to
	// retrieve.
	NextToken *string
	// The name or the unique stack ID that is associated with the stack, which are not
	// always interchangeable:
	//
	//     * Running stacks: You can specify either the
	// stack's name or its unique stack ID.
	//
	//     * Deleted stacks: You must specify the
	// unique stack ID.
	//
	// Default: There is no default value.
	StackName *string
}

type ListStackResourcesOutput struct {
	// If the output exceeds 1 MB, a string that identifies the next page of stack
	// resources. If no additional page exists, this value is null.
	NextToken *string
	// A list of StackResourceSummary structures.
	StackResourceSummaries []*types.StackResourceSummary

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

type ListStackSetOperationResultsInput struct {
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
	// The name or unique ID of the stack set that you want to get operation results
	// for.
	StackSetName *string
	// If the previous request didn't return all of the remaining results, the response
	// object's NextToken parameter value is set to a token. To retrieve the next set
	// of results, call ListStackSetOperationResults again and assign that token to the
	// request object's NextToken parameter. If there are no remaining results, the
	// previous response object's NextToken parameter is set to null.
	NextToken *string
	// The ID of the stack set operation.
	OperationId *string
}

type ListStackSetOperationResultsOutput struct {
	// A list of StackSetOperationResultSummary structures that contain information
	// about the specified operation results, for accounts and Regions that are
	// included in the operation.
	Summaries []*types.StackSetOperationResultSummary
	// If the request doesn't return all results, NextToken is set to a token. To
	// retrieve the next set of results, call ListOperationResults again and assign
	// that token to the request object's NextToken parameter. If there are no
	// remaining results, NextToken is set to null.
	NextToken *string

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

type ListStackSetOperationsInput struct {
	// If the previous paginated request didn't return all of the remaining results,
	// the response object's NextToken parameter value is set to a token. To retrieve
	// the next set of results, call ListStackSetOperations again and assign that token
	// to the request object's NextToken parameter. If there are no remaining results,
	// the previous response object's NextToken parameter is set to null.
	NextToken *string
	// The name or unique ID of the stack set that you want to get operation summaries
	// for.
	StackSetName *string
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
}

type ListStackSetOperationsOutput struct {
	// If the request doesn't return all results, NextToken is set to a token. To
	// retrieve the next set of results, call ListOperationResults again and assign
	// that token to the request object's NextToken parameter. If there are no
	// remaining results, NextToken is set to null.
	NextToken *string
	// A list of StackSetOperationSummary structures that contain summary information
	// about operations for the specified stack set.
	Summaries []*types.StackSetOperationSummary

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

type ListStackSetsInput struct {
	// If the previous paginated request didn't return all of the remaining results,
	// the response object's NextToken parameter value is set to a token. To retrieve
	// the next set of results, call ListStackSets again and assign that token to the
	// request object's NextToken parameter. If there are no remaining results, the
	// previous response object's NextToken parameter is set to null.
	NextToken *string
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
	// The status of the stack sets that you want to get summary information about.
	Status types.StackSetStatus
}

type ListStackSetsOutput struct {
	// If the request doesn't return all of the remaining results, NextToken is set to
	// a token. To retrieve the next set of results, call ListStackInstances again and
	// assign that token to the request object's NextToken parameter. If the request
	// returns all results, NextToken is set to null.
	NextToken *string
	// A list of StackSetSummary structures that contain information about the user's
	// stack sets.
	Summaries []*types.StackSetSummary

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

type ListStacksInput struct {
	// A string that identifies the next page of stacks that you want to retrieve.
	NextToken *string
	// Stack status to use as a filter. Specify one or more stack status codes to list
	// only stacks with the specified status codes. For a complete list of stack status
	// codes, see the StackStatus parameter of the Stack () data type.
	StackStatusFilter []types.StackStatus
}

type ListStacksOutput struct {
	// A list of StackSummary structures containing information about the specified
	// stacks.
	StackSummaries []*types.StackSummary
	// If the output exceeds 1 MB in size, a string that identifies the next page of
	// stacks. If no additional page exists, this value is null.
	NextToken *string

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

type ListTypeRegistrationsInput struct {
	// If the previous paginated request didn't return all of the remaining results,
	// the response object's NextToken parameter value is set to a token. To retrieve
	// the next set of results, call this action again and assign that token to the
	// request object's NextToken parameter. If there are no remaining results, the
	// previous response object's NextToken parameter is set to null.
	NextToken *string
	// The Amazon Resource Name (ARN) of the type. Conditional: You must specify either
	// TypeName and Type, or Arn.
	TypeArn *string
	// The kind of type. Currently the only valid value is RESOURCE. Conditional: You
	// must specify either TypeName and Type, or Arn.
	Type types.RegistryType
	// The current status of the type registration request. The default is IN_PROGRESS.
	RegistrationStatusFilter types.RegistrationStatus
	// The name of the type. Conditional: You must specify either TypeName and Type, or
	// Arn.
	TypeName *string
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
}

type ListTypeRegistrationsOutput struct {
	// A list of type registration tokens. Use DescribeTypeRegistration () to return
	// detailed information about a type registration request.
	RegistrationTokenList []*string
	// If the request doesn't return all of the remaining results, NextToken is set to
	// a token. To retrieve the next set of results, call this action again and assign
	// that token to the request object's NextToken parameter. If the request returns
	// all results, NextToken is set to null.
	NextToken *string

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

type ListTypeVersionsInput struct {
	// The Amazon Resource Name (ARN) of the type for which you want version summary
	// information. Conditional: You must specify either TypeName and Type, or Arn.
	Arn *string
	// The name of the type for which you want version summary information.
	// Conditional: You must specify either TypeName and Type, or Arn.
	TypeName *string
	// The deprecation status of the type versions that you want to get summary
	// information about. Valid values include:
	//
	//     * LIVE: The type version is
	// registered and can be used in CloudFormation operations, dependent on its
	// provisioning behavior and visibility scope.
	//
	//     * DEPRECATED: The type version
	// has been deregistered and can no longer be used in CloudFormation
	// operations.
	//
	// The default is LIVE.
	DeprecatedStatus types.DeprecatedStatus
	// The kind of the type. Currently the only valid value is RESOURCE. Conditional:
	// You must specify either TypeName and Type, or Arn.
	Type types.RegistryType
	// If the previous paginated request didn't return all of the remaining results,
	// the response object's NextToken parameter value is set to a token. To retrieve
	// the next set of results, call this action again and assign that token to the
	// request object's NextToken parameter. If there are no remaining results, the
	// previous response object's NextToken parameter is set to null.
	NextToken *string
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
}

type ListTypeVersionsOutput struct {
	// If the request doesn't return all of the remaining results, NextToken is set to
	// a token. To retrieve the next set of results, call this action again and assign
	// that token to the request object's NextToken parameter. If the request returns
	// all results, NextToken is set to null.
	NextToken *string
	// A list of TypeVersionSummary structures that contain information about the
	// specified type's versions.
	TypeVersionSummaries []*types.TypeVersionSummary

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

type ListTypesInput struct {
	// If the previous paginated request didn't return all of the remaining results,
	// the response object's NextToken parameter value is set to a token. To retrieve
	// the next set of results, call this action again and assign that token to the
	// request object's NextToken parameter. If there are no remaining results, the
	// previous response object's NextToken parameter is set to null.
	NextToken *string
	// The provisioning behavior of the type. AWS CloudFormation determines the
	// provisioning type during registration, based on the types of handlers in the
	// schema handler package submitted. Valid values include:
	//
	//     * FULLY_MUTABLE:
	// The type includes an update handler to process updates to the type during stack
	// update operations.
	//
	//     * IMMUTABLE: The type does not include an update
	// handler, so the type cannot be updated and must instead be replaced during stack
	// update operations.
	//
	//     * NON_PROVISIONABLE: The type does not include create,
	// read, and delete handlers, and therefore cannot actually be provisioned.
	ProvisioningType types.ProvisioningType
	// The maximum number of results to be returned with a single call. If the number
	// of available results exceeds this maximum, the response includes a NextToken
	// value that you can assign to the NextToken request parameter to get the next set
	// of results.
	MaxResults *int32
	// The deprecation status of the types that you want to get summary information
	// about. Valid values include:
	//
	//     * LIVE: The type is registered for use in
	// CloudFormation operations.
	//
	//     * DEPRECATED: The type has been deregistered and
	// can no longer be used in CloudFormation operations.
	DeprecatedStatus types.DeprecatedStatus
	// The scope at which the type is visible and usable in CloudFormation operations.
	// Valid values include:
	//
	//     * PRIVATE: The type is only visible and usable within
	// the account in which it is registered. Currently, AWS CloudFormation marks any
	// types you create as PRIVATE.
	//
	//     * PUBLIC: The type is publically visible and
	// usable within any Amazon account.
	//
	// The default is PRIVATE.
	Visibility types.Visibility
}

type ListTypesOutput struct {
	// A list of TypeSummary structures that contain information about the specified
	// types.
	TypeSummaries []*types.TypeSummary
	// If the request doesn't return all of the remaining results, NextToken is set to
	// a token. To retrieve the next set of results, call this action again and assign
	// that token to the request object's NextToken parameter. If the request returns
	// all results, NextToken is set to null.
	NextToken *string

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

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

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// Provides idempotency tokens values that will be automatically populated into
	// idempotent API operations.
	IdempotencyTokenProvider IdempotencyTokenProvider

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type RecordHandlerProgressInput struct {
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	BearerToken *string
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	CurrentOperationStatus types.OperationStatus
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	ErrorCode types.HandlerErrorCode
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	ClientRequestToken *string
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	OperationStatus types.OperationStatus
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	ResourceModel *string
	// Reserved for use by the CloudFormation CLI
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html).
	StatusMessage *string
}

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

type RegisterTypeInput struct {
	// The Amazon Resource Name (ARN) of the IAM role for CloudFormation to assume when
	// invoking the resource provider. If your resource type calls AWS APIs in any of
	// its handlers, you must create an IAM execution role
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) that includes
	// the necessary permissions to call those AWS APIs, and provision that execution
	// role in your account. When CloudFormation needs to invoke the resource provider
	// handler, CloudFormation assumes this execution role to create a temporary
	// session token, which it then passes to the resource provider handler, thereby
	// supplying your resource provider with the appropriate credentials.
	ExecutionRoleArn *string
	// A unique identifier that acts as an idempotency key for this registration
	// request. Specifying a client request token prevents CloudFormation from
	// generating more than one version of a type from the same registeration request,
	// even if the request is submitted multiple times.
	ClientRequestToken *string
	// The name of the type being registered. We recommend that type names adhere to
	// the following pattern: company_or_organization::service::type. The following
	// organization namespaces are reserved and cannot be used in your resource type
	// names:
	//
	//     * Alexa
	//
	//     * AMZN
	//
	//     * Amazon
	//
	//     * AWS
	//
	//     * Custom
	//
	//     *
	// Dev
	TypeName *string
	// Specifies logging configuration information for a type.
	LoggingConfig *types.LoggingConfig
	// The kind of type. Currently, the only valid value is RESOURCE.
	Type types.RegistryType
	// A url to the S3 bucket containing the schema handler package that contains the
	// schema, event handlers, and associated files for the type you want to register.
	// For information on generating a schema handler package for the type you want to
	// register, see submit
	// (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-cli-submit.html)
	// in the CloudFormation CLI User Guide. As part of registering a resource provider
	// type, CloudFormation must be able to access the S3 bucket which contains the
	// schema handler package for that resource provider. For more information, see IAM
	// Permissions for Registering a Resource Provider
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry.html#registry-register-permissions)
	// in the AWS CloudFormation User Guide.
	SchemaHandlerPackage *string
}

type RegisterTypeOutput struct {
	// The identifier for this registration request. Use this registration token when
	// calling DescribeTypeRegistration (), which returns information about the status
	// and IDs of the type registration.
	RegistrationToken *string

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

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type SetStackPolicyInput struct {
	// Structure containing the stack policy body. For more information, go to  Prevent
	// Updates to Stack Resources
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html)
	// in the AWS CloudFormation User Guide. You can specify either the StackPolicyBody
	// or the StackPolicyURL parameter, but not both.
	StackPolicyBody *string
	// Location of a file containing the stack policy. The URL must point to a policy
	// (maximum size: 16 KB) located in an S3 bucket in the same Region as the stack.
	// You can specify either the StackPolicyBody or the StackPolicyURL parameter, but
	// not both.
	StackPolicyURL *string
	// The name or unique stack ID that you want to associate a policy with.
	StackName *string
}

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

type SetTypeDefaultVersionInput struct {
	// The Amazon Resource Name (ARN) of the type for which you want version summary
	// information. Conditional: You must specify either TypeName and Type, or Arn.
	Arn *string
	// The name of the type. Conditional: You must specify either TypeName and Type, or
	// Arn.
	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
	// The kind of type. Conditional: You must specify either TypeName and Type, or
	// Arn.
	Type types.RegistryType
}

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

type SignalResourceInput struct {
	// The stack name or unique stack ID that includes the resource that you want to
	// signal.
	StackName *string
	// The logical ID of the resource that you want to signal. The logical ID is the
	// name of the resource that given in the template.
	LogicalResourceId *string
	// The status of the signal, which is either success or failure. A failure signal
	// causes AWS CloudFormation to immediately fail the stack creation or update.
	Status types.ResourceSignalStatus
	// A unique ID of the signal. When you signal Amazon EC2 instances or Auto Scaling
	// groups, specify the instance ID that you are signaling as the unique ID. If you
	// send multiple signals to a single resource (such as signaling a wait condition),
	// each signal requires a different unique ID.
	UniqueId *string
}

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

type StopStackSetOperationInput struct {
	// The ID of the stack operation.
	OperationId *string
	// The name or unique ID of the stack set that you want to stop the operation for.
	StackSetName *string
}

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

type UpdateStackInput struct {
	// The name or unique stack ID of the stack to update.
	StackName *string
	// Location of a file containing the temporary overriding stack policy. The URL
	// must point to a policy (max size: 16KB) located in an S3 bucket in the same
	// Region as the stack. You can specify either the StackPolicyDuringUpdateBody or
	// the StackPolicyDuringUpdateURL parameter, but not both. If you want to update
	// protected resources, specify a temporary overriding stack policy during this
	// update. If you do not specify a stack policy, the current policy that is
	// associated with the stack will be used.
	StackPolicyDuringUpdateURL *string
	// Structure containing a new stack policy body. You can specify either the
	// StackPolicyBody or the StackPolicyURL parameter, but not both. You might update
	// the stack policy, for example, in order to protect a new resource that you
	// created during a stack update. If you do not specify a stack policy, the current
	// policy that is associated with the stack is unchanged.
	StackPolicyBody *string
	// Structure containing the template body with a minimum length of 1 byte and a
	// maximum length of 51,200 bytes. (For more information, go to Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide.) Conditional: You must specify only one of
	// the following parameters: TemplateBody, TemplateURL, or set the
	// UsePreviousTemplate to true.
	TemplateBody *string
	// The template resource types that you have permissions to work with for this
	// update stack action, such as AWS::EC2::Instance, AWS::EC2::*, or
	// Custom::MyCustomInstance. If the list of resource types doesn't include a
	// resource that you're updating, the stack update fails. By default, AWS
	// CloudFormation grants permissions to all resource types. AWS Identity and Access
	// Management (IAM) uses this parameter for AWS CloudFormation-specific condition
	// keys in IAM policies. For more information, see Controlling Access with AWS
	// Identity and Access Management
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html).
	ResourceTypes []*string
	// The rollback triggers for AWS CloudFormation to monitor during stack creation
	// and updating operations, and for the specified monitoring period afterwards.
	RollbackConfiguration *types.RollbackConfiguration
	// Reuse the existing template that is associated with the stack that you are
	// updating. Conditional: You must specify only one of the following parameters:
	// TemplateBody, TemplateURL, or set the UsePreviousTemplate to true.
	UsePreviousTemplate *bool
	// The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM)
	// role that AWS CloudFormation assumes to update the stack. AWS CloudFormation
	// uses the role's credentials to make calls on your behalf. AWS CloudFormation
	// always uses this role for all future operations on the stack. As long as users
	// have permission to operate on the stack, AWS CloudFormation uses this role even
	// if the users don't have permission to pass it. Ensure that the role grants least
	// privilege. If you don't specify a value, AWS CloudFormation uses the role that
	// was previously associated with the stack. If no role is available, AWS
	// CloudFormation uses a temporary session that is generated from your user
	// credentials.
	RoleARN *string
	// Structure containing the temporary overriding stack policy body. You can specify
	// either the StackPolicyDuringUpdateBody or the StackPolicyDuringUpdateURL
	// parameter, but not both. If you want to update protected resources, specify a
	// temporary overriding stack policy during this update. If you do not specify a
	// stack policy, the current policy that is associated with the stack will be used.
	StackPolicyDuringUpdateBody *string
	// A list of Parameter structures that specify input parameters for the stack. For
	// more information, see the Parameter
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html)
	// data type.
	Parameters []*types.Parameter
	// Location of a file containing the updated stack policy. The URL must point to a
	// policy (max size: 16KB) located in an S3 bucket in the same Region as the stack.
	// You can specify either the StackPolicyBody or the StackPolicyURL parameter, but
	// not both. You might update the stack policy, for example, in order to protect a
	// new resource that you created during a stack update. If you do not specify a
	// stack policy, the current policy that is associated with the stack is unchanged.
	StackPolicyURL *string
	// Amazon Simple Notification Service topic Amazon Resource Names (ARNs) that AWS
	// CloudFormation associates with the stack. Specify an empty list to remove all
	// notification topics.
	NotificationARNs []*string
	// Location of file containing the template body. The URL must point to a template
	// that is located in an Amazon S3 bucket. For more information, go to Template
	// Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify only one of
	// the following parameters: TemplateBody, TemplateURL, or set the
	// UsePreviousTemplate to true.
	TemplateURL *string
	// In some cases, you must explicitly acknowledge that your stack template contains
	// certain capabilities in order for AWS CloudFormation to update the stack.
	//
	//     *
	// CAPABILITY_IAM and CAPABILITY_NAMED_IAM Some stack 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 those stacks,
	// you must explicitly acknowledge this by specifying one of these capabilities.
	// The following IAM resources require you to specify either the CAPABILITY_IAM or
	// CAPABILITY_NAMED_IAM capability.
	//
	//         * If you have IAM resources, you can
	// specify either capability.
	//
	//         * If you have IAM resources with custom
	// names, you must specify CAPABILITY_NAMED_IAM.
	//
	//         * If you don't specify
	// either of these capabilities, AWS CloudFormation returns an
	// InsufficientCapabilities error.
	//
	//     If your stack template contains these
	// resources, we recommend that you review all permissions associated with them and
	// edit their permissions if necessary.
	//
	//         * AWS::IAM::AccessKey
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html)
	//
	//
	// * AWS::IAM::Group
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html)
	//
	//
	// * AWS::IAM::InstanceProfile
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html)
	//
	//
	// * AWS::IAM::Policy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html)
	//
	//
	// * AWS::IAM::Role
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)
	//
	//
	// * AWS::IAM::User
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html)
	//
	//
	// * AWS::IAM::UserToGroupAddition
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html)
	//
	//
	// For more information, see Acknowledging IAM Resources in AWS CloudFormation
	// Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities).
	//
	//
	// * CAPABILITY_AUTO_EXPAND Some template contain macros. Macros perform custom
	// processing on templates; this can include simple actions like find-and-replace
	// operations, all the way to extensive transformations of entire templates.
	// Because of this, users typically create a change set from the processed
	// template, so that they can review the changes resulting from the macros before
	// actually updating the stack. If your stack template contains one or more macros,
	// and you choose to update a stack directly from the processed template, without
	// first reviewing the resulting changes in a change set, you must acknowledge this
	// capability. This includes the AWS::Include
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html)
	// and AWS::Serverless
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html)
	// transforms, which are macros hosted by AWS CloudFormation. Change sets do not
	// currently support nested stacks. If you want to update a stack from a stack
	// template that contains macros and nested stacks, you must update the stack
	// directly from the template using this capability. You should only update stacks
	// directly from a stack template that contains macros if you know what processing
	// the macro performs. Each macro relies on an underlying Lambda service function
	// for processing stack templates. Be aware that the Lambda function owner can
	// update the function operation without AWS CloudFormation being notified. For
	// more information, see Using AWS CloudFormation Macros to Perform Custom
	// Processing on Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html).
	Capabilities []types.Capability
	// A unique identifier for this UpdateStack request. Specify this token if you plan
	// to retry requests so that AWS CloudFormation knows that you're not attempting to
	// update a stack with the same name. You might retry UpdateStack requests to
	// ensure that AWS CloudFormation successfully received them. 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
	// Key-value pairs to associate with this stack. AWS CloudFormation also propagates
	// these tags to supported resources in the stack. You can specify a maximum number
	// of 50 tags. If you don't specify this parameter, AWS CloudFormation doesn't
	// modify the stack's tags. If you specify an empty value, AWS CloudFormation
	// removes all associated tags.
	Tags []*types.Tag
}

type UpdateStackInstancesInput struct {
	// A list of input parameters whose values you want to update for the specified
	// stack instances. Any overridden parameter values will be applied to all stack
	// instances in the specified accounts and Regions. When specifying parameters and
	// their values, be aware of how AWS CloudFormation sets parameter values during
	// stack instance update operations:
	//
	//     * To override the current value for a
	// parameter, include the parameter and specify its value.
	//
	//     * To leave a
	// parameter set to its present value, you can do one of the following:
	//
	//         *
	// Do not include the parameter in the list.
	//
	//         * Include the parameter and
	// specify UsePreviousValue as true. (You cannot specify both a value and set
	// UsePreviousValue to true.)
	//
	//     * To set all overridden parameter back to the
	// values specified in the stack set, specify a parameter list but do not include
	// any parameters.
	//
	//     * To leave all parameters set to their present values, do
	// not specify this property at all.
	//
	// During stack set updates, any parameter
	// values overridden for a stack instance are not updated, but retain their
	// overridden value. You can only override the parameter values that are specified
	// in the stack set; to add or delete a parameter itself, use UpdateStackSet to
	// update the stack set template. If you add a parameter to a template, before you
	// can override the parameter value specified in the stack set you must first use
	// UpdateStackSet
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html)
	// to update all stack instances with the updated template and parameter value
	// specified in the stack set. Once a stack instance has been updated with the new
	// parameter, you can then override the parameter value using UpdateStackInstances.
	ParameterOverrides []*types.Parameter
	// Preferences for how AWS CloudFormation performs this stack set operation.
	OperationPreferences *types.StackSetOperationPreferences
	// [Service-managed permissions] The AWS Organizations accounts for which you want
	// to update parameter values for stack instances. If your update targets OUs, the
	// overridden parameter values only apply to the accounts that are currently in the
	// target OUs and their child OUs. Accounts added to the target OUs and their child
	// OUs in the future won't use the overridden values. You can specify Accounts or
	// DeploymentTargets, but not both.
	DeploymentTargets *types.DeploymentTargets
	// The names of one or more Regions in which you want to update parameter values
	// for stack instances. The overridden parameter values will be applied to all
	// stack instances in the specified accounts and Regions.
	Regions []*string
	// The name or unique ID of the stack set associated with the stack instances.
	StackSetName *string
	// [Self-managed permissions] The names of one or more AWS accounts for which you
	// want to update parameter values for stack instances. The overridden parameter
	// values will be applied to all stack instances in the specified accounts and
	// Regions. You can specify Accounts or DeploymentTargets, but not both.
	Accounts []*string
	// The unique identifier for this stack set operation. The operation ID also
	// functions as an idempotency token, to ensure that AWS CloudFormation performs
	// the stack set operation only once, even if you retry the request multiple times.
	// You might retry stack set operation requests to ensure that AWS CloudFormation
	// successfully received them. If you don't specify an operation ID, the SDK
	// generates one automatically.
	OperationId *string
}

type UpdateStackInstancesOutput struct {
	// The unique identifier for this stack set operation.
	OperationId *string

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

type UpdateStackOutput struct {
	// Unique identifier of the stack.
	StackId *string

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

type UpdateStackSetInput struct {
	// The structure that contains the template body, with a minimum length of 1 byte
	// and a maximum length of 51,200 bytes. For more information, see Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify only one of
	// the following parameters: TemplateBody or TemplateURL—or set UsePreviousTemplate
	// to true.
	TemplateBody *string
	// Describes how the IAM roles required for stack set operations are created. You
	// cannot modify PermissionModel if there are stack instances associated with your
	// stack set.
	//
	//     * 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 types.PermissionModels
	// The unique ID for this stack set operation. The operation ID also functions as
	// an idempotency token, to ensure that AWS CloudFormation performs the stack set
	// operation only once, even if you retry the request multiple times. You might
	// retry stack set operation requests to ensure that AWS CloudFormation
	// successfully received them. If you don't specify an operation ID, AWS
	// CloudFormation generates one automatically. Repeating this stack set operation
	// with a new operation ID retries all stack instances whose status is OUTDATED.
	OperationId *string
	// [Self-managed permissions] The accounts in which to update associated stack
	// instances. If you specify accounts, you must also specify the Regions in which
	// to update stack set instances. To update all the stack instances associated with
	// this stack set, do not specify the Accounts or Regions properties. If the stack
	// set update includes changes to the template (that is, if the TemplateBody or
	// TemplateURL properties are specified), or the Parameters property, AWS
	// CloudFormation marks all stack instances with a status of OUTDATED prior to
	// updating the stack instances in the specified accounts and Regions. If the stack
	// set update does not include changes to the template or parameters, AWS
	// CloudFormation updates the stack instances in the specified accounts and
	// Regions, while leaving all other stack instances with their existing stack
	// instance status.
	Accounts []*string
	// [Service-managed permissions] Describes whether StackSets automatically deploys
	// to AWS Organizations accounts that are added to a target organization or
	// organizational unit (OU). If you specify AutoDeployment, do not specify
	// DeploymentTargets or Regions.
	AutoDeployment *types.AutoDeployment
	// A brief description of updates that you are making.
	Description *string
	// The key-value pairs to associate with this stack set and the stacks created from
	// it. AWS CloudFormation also propagates these tags to supported resources that
	// are created in the stacks. You can specify a maximum number of 50 tags. If you
	// specify tags for this parameter, those tags replace any list of tags that are
	// currently associated with this stack set. This means:
	//
	//     * If you don't
	// specify this parameter, AWS CloudFormation doesn't modify the stack's tags.
	//
	//
	// * If you specify any tags using this parameter, you must specify all the tags
	// that you want associated with this stack set, even tags you've specifed before
	// (for example, when creating the stack set or during a previous update of the
	// stack set.). Any tags that you don't include in the updated list of tags are
	// removed from the stack set, and therefore from the stacks and resources as
	// well.
	//
	//     * If you specify an empty value, AWS CloudFormation removes all
	// currently associated tags.
	//
	// If you specify new tags as part of an UpdateStackSet
	// action, AWS CloudFormation checks to see if you have the required IAM permission
	// to tag resources. If you omit tags that are currently associated with the stack
	// set from the list of tags you specify, AWS CloudFormation assumes that you want
	// to remove those tags from the stack set, and checks to see if you have
	// permission to untag resources. If you don't have the necessary permission(s),
	// the entire UpdateStackSet action fails with an access denied error, and the
	// stack set is not updated.
	Tags []*types.Tag
	// In some cases, you must explicitly acknowledge that your stack template contains
	// certain capabilities in order for AWS CloudFormation to update the stack set and
	// its associated stack instances.
	//
	//     * CAPABILITY_IAM and CAPABILITY_NAMED_IAM
	// Some stack 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 those stacks sets, you must explicitly acknowledge this by
	// specifying one of these capabilities. The following IAM resources require you to
	// specify either the CAPABILITY_IAM or CAPABILITY_NAMED_IAM capability.
	//
	//         *
	// If you have IAM resources, you can specify either capability.
	//
	//         * If you
	// have IAM resources with custom names, you must specify CAPABILITY_NAMED_IAM.
	//
	//
	// * If you don't specify either of these capabilities, AWS CloudFormation returns
	// an InsufficientCapabilities error.
	//
	//     If your stack template contains these
	// resources, we recommend that you review all permissions associated with them and
	// edit their permissions if necessary.
	//
	//         * AWS::IAM::AccessKey
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html)
	//
	//
	// * AWS::IAM::Group
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html)
	//
	//
	// * AWS::IAM::InstanceProfile
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html)
	//
	//
	// * AWS::IAM::Policy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html)
	//
	//
	// * AWS::IAM::Role
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)
	//
	//
	// * AWS::IAM::User
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html)
	//
	//
	// * AWS::IAM::UserToGroupAddition
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html)
	//
	//
	// For more information, see Acknowledging IAM Resources in AWS CloudFormation
	// Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities).
	//
	//
	// * CAPABILITY_AUTO_EXPAND Some templates contain macros. If your stack template
	// contains one or more macros, and you choose to update a stack directly from the
	// processed template, without first reviewing the resulting changes in a change
	// set, you must acknowledge this capability. For more information, see Using AWS
	// CloudFormation Macros to Perform Custom Processing on Templates
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html).
	// Stack sets do not currently support macros in stack templates. (This includes
	// the AWS::Include
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html)
	// and AWS::Serverless
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html)
	// transforms, which are macros hosted by AWS CloudFormation.) Even if you specify
	// this capability, if you include a macro in your template the stack set operation
	// will fail.
	Capabilities []types.Capability
	// The location of the file that contains the template body. The URL must point to
	// a template (maximum size: 460,800 bytes) that is located in an Amazon S3 bucket.
	// For more information, see Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must specify only one of
	// the following parameters: TemplateBody or TemplateURL—or set UsePreviousTemplate
	// to true.
	TemplateURL *string
	// The name of the IAM execution role to use to update the stack set. If you do not
	// specify an execution role, AWS CloudFormation uses the
	// AWSCloudFormationStackSetExecutionRole role for the stack set operation. Specify
	// an IAM role only if you are using customized execution roles to control which
	// stack resources users and groups can include in their stack sets. If you specify
	// a customized execution role, AWS CloudFormation uses that role to update the
	// stack. If you do not specify a customized execution role, AWS CloudFormation
	// performs the update using the role previously associated with the stack set, so
	// long as you have permissions to perform operations on the stack set.
	ExecutionRoleName *string
	// The Amazon Resource Number (ARN) of the IAM role to use to update this stack
	// set. Specify an IAM role only if you are using customized administrator roles to
	// control which users or groups can manage specific stack sets within the same
	// administrator account. For more information, see Granting Permissions for Stack
	// Set Operations
	// (http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs.html)
	// in the AWS CloudFormation User Guide. If you specified a customized
	// administrator role when you created the stack set, you must specify a customized
	// administrator role, even if it is the same customized administrator role used
	// with this stack set previously.
	AdministrationRoleARN *string
	// The name or unique ID of the stack set that you want to update.
	StackSetName *string
	// The Regions in which to update associated stack instances. If you specify
	// Regions, you must also specify accounts in which to update stack set instances.
	// To update all the stack instances associated with this stack set, do not specify
	// the Accounts or Regions properties. If the stack set update includes changes to
	// the template (that is, if the TemplateBody or TemplateURL properties are
	// specified), or the Parameters property, AWS CloudFormation marks all stack
	// instances with a status of OUTDATED prior to updating the stack instances in the
	// specified accounts and Regions. If the stack set update does not include changes
	// to the template or parameters, AWS CloudFormation updates the stack instances in
	// the specified accounts and Regions, while leaving all other stack instances with
	// their existing stack instance status.
	Regions []*string
	// A list of input parameters for the stack set template.
	Parameters []*types.Parameter
	// Preferences for how AWS CloudFormation performs this stack set operation.
	OperationPreferences *types.StackSetOperationPreferences
	// Use the existing template that's associated with the stack set that you're
	// updating. Conditional: You must specify only one of the following parameters:
	// TemplateBody or TemplateURL—or set UsePreviousTemplate to true.
	UsePreviousTemplate *bool
	// [Service-managed permissions] The AWS Organizations accounts in which to update
	// associated stack instances. To update all the stack instances associated with
	// this stack set, do not specify DeploymentTargets or Regions. If the stack set
	// update includes changes to the template (that is, if TemplateBody or TemplateURL
	// is specified), or the Parameters, AWS CloudFormation marks all stack instances
	// with a status of OUTDATED prior to updating the stack instances in the specified
	// accounts and Regions. If the stack set update does not include changes to the
	// template or parameters, AWS CloudFormation updates the stack instances in the
	// specified accounts and Regions, while leaving all other stack instances with
	// their existing stack instance status.
	DeploymentTargets *types.DeploymentTargets
}

type UpdateStackSetOutput struct {
	// The unique ID for this stack set operation.
	OperationId *string

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

type UpdateTerminationProtectionInput struct {
	// Whether to enable termination protection on the specified stack.
	EnableTerminationProtection *bool
	// The name or unique ID of the stack for which you want to set termination
	// protection.
	StackName *string
}

type UpdateTerminationProtectionOutput struct {
	// The unique ID of the stack.
	StackId *string

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

type ValidateTemplateInput struct {
	// Location of file containing the template body. The URL must point to a template
	// (max size: 460,800 bytes) that is located in an Amazon S3 bucket. For more
	// information, go to Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must pass TemplateURL or
	// TemplateBody. If both are passed, only TemplateBody is used.
	TemplateURL *string
	// Structure containing the template body with a minimum length of 1 byte and a
	// maximum length of 51,200 bytes. For more information, go to Template Anatomy
	// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html)
	// in the AWS CloudFormation User Guide. Conditional: You must pass TemplateURL or
	// TemplateBody. If both are passed, only TemplateBody is used.
	TemplateBody *string
}

type ValidateTemplateOutput struct {
	// A list of TemplateParameter structures.
	Parameters []*types.TemplateParameter
	// The list of resources that generated the values in the Capabilities response
	// element.
	CapabilitiesReason *string
	// A list of the transforms that are declared in the template.
	DeclaredTransforms []*string
	// The capabilities found within the template. If your template contains IAM
	// resources, you must specify the CAPABILITY_IAM or CAPABILITY_NAMED_IAM value for
	// this parameter when you use the CreateStack () or UpdateStack () actions with
	// your template; otherwise, those actions return an InsufficientCapabilities
	// error. 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 []types.Capability
	// The description found within the template.
	Description *string

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