@aws-sdk/client-cloudformation 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,3056 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare type AccountGateStatus = "FAILED" | "SKIPPED" | "SUCCEEDED";
+
+export interface AccountGateResult {
+    
+    Status?: AccountGateStatus | string;
+    
+    StatusReason?: string;
+}
+export declare namespace AccountGateResult {
+    
+    const filterSensitiveLog: (obj: AccountGateResult) => any;
+}
+
+export interface AccountLimit {
+    
+    Name?: string;
+    
+    Value?: number;
+}
+export declare namespace AccountLimit {
+    
+    const filterSensitiveLog: (obj: AccountLimit) => any;
+}
+
+export interface LoggingConfig {
+    
+    LogRoleArn: string | undefined;
+    
+    LogGroupName: string | undefined;
+}
+export declare namespace LoggingConfig {
+    
+    const filterSensitiveLog: (obj: LoggingConfig) => any;
+}
+export declare enum ThirdPartyType {
+    MODULE = "MODULE",
+    RESOURCE = "RESOURCE"
+}
+export declare enum VersionBump {
+    MAJOR = "MAJOR",
+    MINOR = "MINOR"
+}
+export interface ActivateTypeInput {
+    
+    Type?: ThirdPartyType | string;
+    
+    PublicTypeArn?: string;
+    
+    PublisherId?: string;
+    
+    TypeName?: string;
+    
+    TypeNameAlias?: string;
+    
+    AutoUpdate?: boolean;
+    
+    LoggingConfig?: LoggingConfig;
+    
+    ExecutionRoleArn?: string;
+    
+    VersionBump?: VersionBump | string;
+    
+    MajorVersion?: number;
+}
+export declare namespace ActivateTypeInput {
+    
+    const filterSensitiveLog: (obj: ActivateTypeInput) => any;
+}
+export interface ActivateTypeOutput {
+    
+    Arn?: string;
+}
+export declare namespace ActivateTypeOutput {
+    
+    const filterSensitiveLog: (obj: ActivateTypeOutput) => any;
+}
+
+export interface CFNRegistryException extends __SmithyException, $MetadataBearer {
+    name: "CFNRegistryException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface TypeNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "TypeNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface AlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "AlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface AutoDeployment {
+    
+    Enabled?: boolean;
+    
+    RetainStacksOnAccountRemoval?: boolean;
+}
+export declare namespace AutoDeployment {
+    
+    const filterSensitiveLog: (obj: AutoDeployment) => any;
+}
+
+export interface TypeConfigurationIdentifier {
+    
+    TypeArn?: string;
+    
+    TypeConfigurationAlias?: string;
+    
+    TypeConfigurationArn?: string;
+    
+    Type?: ThirdPartyType | string;
+    
+    TypeName?: string;
+}
+export declare namespace TypeConfigurationIdentifier {
+    
+    const filterSensitiveLog: (obj: TypeConfigurationIdentifier) => any;
+}
+export interface BatchDescribeTypeConfigurationsInput {
+    
+    TypeConfigurationIdentifiers: TypeConfigurationIdentifier[] | undefined;
+}
+export declare namespace BatchDescribeTypeConfigurationsInput {
+    
+    const filterSensitiveLog: (obj: BatchDescribeTypeConfigurationsInput) => any;
+}
+
+export interface BatchDescribeTypeConfigurationsError {
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    TypeConfigurationIdentifier?: TypeConfigurationIdentifier;
+}
+export declare namespace BatchDescribeTypeConfigurationsError {
+    
+    const filterSensitiveLog: (obj: BatchDescribeTypeConfigurationsError) => any;
+}
+
+export interface TypeConfigurationDetails {
+    
+    Arn?: string;
+    
+    Alias?: string;
+    
+    Configuration?: string;
+    
+    LastUpdated?: Date;
+    
+    TypeArn?: string;
+    
+    TypeName?: string;
+    
+    IsDefaultConfiguration?: boolean;
+}
+export declare namespace TypeConfigurationDetails {
+    
+    const filterSensitiveLog: (obj: TypeConfigurationDetails) => any;
+}
+export interface BatchDescribeTypeConfigurationsOutput {
+    
+    Errors?: BatchDescribeTypeConfigurationsError[];
+    
+    UnprocessedTypeConfigurations?: TypeConfigurationIdentifier[];
+    
+    TypeConfigurations?: TypeConfigurationDetails[];
+}
+export declare namespace BatchDescribeTypeConfigurationsOutput {
+    
+    const filterSensitiveLog: (obj: BatchDescribeTypeConfigurationsOutput) => any;
+}
+
+export interface TypeConfigurationNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "TypeConfigurationNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum CallAs {
+    DELEGATED_ADMIN = "DELEGATED_ADMIN",
+    SELF = "SELF"
+}
+
+export interface CancelUpdateStackInput {
+    
+    StackName: string | undefined;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace CancelUpdateStackInput {
+    
+    const filterSensitiveLog: (obj: CancelUpdateStackInput) => any;
+}
+
+export interface TokenAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "TokenAlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum Capability {
+    CAPABILITY_AUTO_EXPAND = "CAPABILITY_AUTO_EXPAND",
+    CAPABILITY_IAM = "CAPABILITY_IAM",
+    CAPABILITY_NAMED_IAM = "CAPABILITY_NAMED_IAM"
+}
+export declare enum Category {
+    ACTIVATED = "ACTIVATED",
+    AWS_TYPES = "AWS_TYPES",
+    REGISTERED = "REGISTERED",
+    THIRD_PARTY = "THIRD_PARTY"
+}
+export declare enum ChangeAction {
+    Add = "Add",
+    Dynamic = "Dynamic",
+    Import = "Import",
+    Modify = "Modify",
+    Remove = "Remove"
+}
+export declare enum ChangeSource {
+    Automatic = "Automatic",
+    DirectModification = "DirectModification",
+    ParameterReference = "ParameterReference",
+    ResourceAttribute = "ResourceAttribute",
+    ResourceReference = "ResourceReference"
+}
+export declare enum EvaluationType {
+    Dynamic = "Dynamic",
+    Static = "Static"
+}
+export declare enum ResourceAttribute {
+    CreationPolicy = "CreationPolicy",
+    DeletionPolicy = "DeletionPolicy",
+    Metadata = "Metadata",
+    Properties = "Properties",
+    Tags = "Tags",
+    UpdatePolicy = "UpdatePolicy"
+}
+export declare enum RequiresRecreation {
+    Always = "Always",
+    Conditionally = "Conditionally",
+    Never = "Never"
+}
+
+export interface ResourceTargetDefinition {
+    
+    Attribute?: ResourceAttribute | string;
+    
+    Name?: string;
+    
+    RequiresRecreation?: RequiresRecreation | string;
+}
+export declare namespace ResourceTargetDefinition {
+    
+    const filterSensitiveLog: (obj: ResourceTargetDefinition) => any;
+}
+
+export interface ResourceChangeDetail {
+    
+    Target?: ResourceTargetDefinition;
+    
+    Evaluation?: EvaluationType | string;
+    
+    ChangeSource?: ChangeSource | string;
+    
+    CausingEntity?: string;
+}
+export declare namespace ResourceChangeDetail {
+    
+    const filterSensitiveLog: (obj: ResourceChangeDetail) => any;
+}
+
+export interface ModuleInfo {
+    
+    TypeHierarchy?: string;
+    
+    LogicalIdHierarchy?: string;
+}
+export declare namespace ModuleInfo {
+    
+    const filterSensitiveLog: (obj: ModuleInfo) => any;
+}
+export declare enum Replacement {
+    Conditional = "Conditional",
+    False = "False",
+    True = "True"
+}
+
+export interface ResourceChange {
+    
+    Action?: ChangeAction | string;
+    
+    LogicalResourceId?: string;
+    
+    PhysicalResourceId?: string;
+    
+    ResourceType?: string;
+    
+    Replacement?: Replacement | string;
+    
+    Scope?: (ResourceAttribute | string)[];
+    
+    Details?: ResourceChangeDetail[];
+    
+    ChangeSetId?: string;
+    
+    ModuleInfo?: ModuleInfo;
+}
+export declare namespace ResourceChange {
+    
+    const filterSensitiveLog: (obj: ResourceChange) => any;
+}
+export declare enum ChangeType {
+    Resource = "Resource"
+}
+
+export interface Change {
+    
+    Type?: ChangeType | string;
+    
+    ResourceChange?: ResourceChange;
+}
+export declare namespace Change {
+    
+    const filterSensitiveLog: (obj: Change) => any;
+}
+
+export interface ChangeSetNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ChangeSetNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum ChangeSetStatus {
+    CREATE_COMPLETE = "CREATE_COMPLETE",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    CREATE_PENDING = "CREATE_PENDING",
+    DELETE_COMPLETE = "DELETE_COMPLETE",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    DELETE_PENDING = "DELETE_PENDING",
+    FAILED = "FAILED"
+}
+export declare enum ExecutionStatus {
+    AVAILABLE = "AVAILABLE",
+    EXECUTE_COMPLETE = "EXECUTE_COMPLETE",
+    EXECUTE_FAILED = "EXECUTE_FAILED",
+    EXECUTE_IN_PROGRESS = "EXECUTE_IN_PROGRESS",
+    OBSOLETE = "OBSOLETE",
+    UNAVAILABLE = "UNAVAILABLE"
+}
+
+export interface ChangeSetSummary {
+    
+    StackId?: string;
+    
+    StackName?: string;
+    
+    ChangeSetId?: string;
+    
+    ChangeSetName?: string;
+    
+    ExecutionStatus?: ExecutionStatus | string;
+    
+    Status?: ChangeSetStatus | string;
+    
+    StatusReason?: string;
+    
+    CreationTime?: Date;
+    
+    Description?: string;
+    
+    IncludeNestedStacks?: boolean;
+    
+    ParentChangeSetId?: string;
+    
+    RootChangeSetId?: string;
+}
+export declare namespace ChangeSetSummary {
+    
+    const filterSensitiveLog: (obj: ChangeSetSummary) => any;
+}
+export declare enum ChangeSetType {
+    CREATE = "CREATE",
+    IMPORT = "IMPORT",
+    UPDATE = "UPDATE"
+}
+
+export interface ContinueUpdateRollbackInput {
+    
+    StackName: string | undefined;
+    
+    RoleARN?: string;
+    
+    ResourcesToSkip?: string[];
+    
+    ClientRequestToken?: string;
+}
+export declare namespace ContinueUpdateRollbackInput {
+    
+    const filterSensitiveLog: (obj: ContinueUpdateRollbackInput) => any;
+}
+
+export interface ContinueUpdateRollbackOutput {
+}
+export declare namespace ContinueUpdateRollbackOutput {
+    
+    const filterSensitiveLog: (obj: ContinueUpdateRollbackOutput) => any;
+}
+
+export interface Parameter {
+    
+    ParameterKey?: string;
+    
+    ParameterValue?: string;
+    
+    UsePreviousValue?: boolean;
+    
+    ResolvedValue?: string;
+}
+export declare namespace Parameter {
+    
+    const filterSensitiveLog: (obj: Parameter) => any;
+}
+
+export interface ResourceToImport {
+    
+    ResourceType: string | undefined;
+    
+    LogicalResourceId: string | undefined;
+    
+    ResourceIdentifier: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace ResourceToImport {
+    
+    const filterSensitiveLog: (obj: ResourceToImport) => any;
+}
+
+export interface RollbackTrigger {
+    
+    Arn: string | undefined;
+    
+    Type: string | undefined;
+}
+export declare namespace RollbackTrigger {
+    
+    const filterSensitiveLog: (obj: RollbackTrigger) => any;
+}
+
+export interface RollbackConfiguration {
+    
+    RollbackTriggers?: RollbackTrigger[];
+    
+    MonitoringTimeInMinutes?: number;
+}
+export declare namespace RollbackConfiguration {
+    
+    const filterSensitiveLog: (obj: RollbackConfiguration) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface CreateChangeSetInput {
+    
+    StackName: string | undefined;
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    UsePreviousTemplate?: boolean;
+    
+    Parameters?: Parameter[];
+    
+    Capabilities?: (Capability | string)[];
+    
+    ResourceTypes?: string[];
+    
+    RoleARN?: string;
+    
+    RollbackConfiguration?: RollbackConfiguration;
+    
+    NotificationARNs?: string[];
+    
+    Tags?: Tag[];
+    
+    ChangeSetName: string | undefined;
+    
+    ClientToken?: string;
+    
+    Description?: string;
+    
+    ChangeSetType?: ChangeSetType | string;
+    
+    ResourcesToImport?: ResourceToImport[];
+    
+    IncludeNestedStacks?: boolean;
+}
+export declare namespace CreateChangeSetInput {
+    
+    const filterSensitiveLog: (obj: CreateChangeSetInput) => any;
+}
+
+export interface CreateChangeSetOutput {
+    
+    Id?: string;
+    
+    StackId?: string;
+}
+export declare namespace CreateChangeSetOutput {
+    
+    const filterSensitiveLog: (obj: CreateChangeSetOutput) => any;
+}
+
+export interface InsufficientCapabilitiesException extends __SmithyException, $MetadataBearer {
+    name: "InsufficientCapabilitiesException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum OnFailure {
+    DELETE = "DELETE",
+    DO_NOTHING = "DO_NOTHING",
+    ROLLBACK = "ROLLBACK"
+}
+
+export interface CreateStackInput {
+    
+    StackName: string | undefined;
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    Parameters?: Parameter[];
+    
+    DisableRollback?: boolean;
+    
+    RollbackConfiguration?: RollbackConfiguration;
+    
+    TimeoutInMinutes?: number;
+    
+    NotificationARNs?: string[];
+    
+    Capabilities?: (Capability | string)[];
+    
+    ResourceTypes?: string[];
+    
+    RoleARN?: string;
+    
+    OnFailure?: OnFailure | string;
+    
+    StackPolicyBody?: string;
+    
+    StackPolicyURL?: string;
+    
+    Tags?: Tag[];
+    
+    ClientRequestToken?: string;
+    
+    EnableTerminationProtection?: boolean;
+}
+export declare namespace CreateStackInput {
+    
+    const filterSensitiveLog: (obj: CreateStackInput) => any;
+}
+
+export interface CreateStackOutput {
+    
+    StackId?: string;
+}
+export declare namespace CreateStackOutput {
+    
+    const filterSensitiveLog: (obj: CreateStackOutput) => any;
+}
+
+export interface DeploymentTargets {
+    
+    Accounts?: string[];
+    
+    AccountsUrl?: string;
+    
+    OrganizationalUnitIds?: string[];
+}
+export declare namespace DeploymentTargets {
+    
+    const filterSensitiveLog: (obj: DeploymentTargets) => any;
+}
+export declare enum RegionConcurrencyType {
+    PARALLEL = "PARALLEL",
+    SEQUENTIAL = "SEQUENTIAL"
+}
+
+export interface StackSetOperationPreferences {
+    
+    RegionConcurrencyType?: RegionConcurrencyType | string;
+    
+    RegionOrder?: string[];
+    
+    FailureToleranceCount?: number;
+    
+    FailureTolerancePercentage?: number;
+    
+    MaxConcurrentCount?: number;
+    
+    MaxConcurrentPercentage?: number;
+}
+export declare namespace StackSetOperationPreferences {
+    
+    const filterSensitiveLog: (obj: StackSetOperationPreferences) => any;
+}
+export interface CreateStackInstancesInput {
+    
+    StackSetName: string | undefined;
+    
+    Accounts?: string[];
+    
+    DeploymentTargets?: DeploymentTargets;
+    
+    Regions: string[] | undefined;
+    
+    ParameterOverrides?: Parameter[];
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    OperationId?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace CreateStackInstancesInput {
+    
+    const filterSensitiveLog: (obj: CreateStackInstancesInput) => any;
+}
+export interface CreateStackInstancesOutput {
+    
+    OperationId?: string;
+}
+export declare namespace CreateStackInstancesOutput {
+    
+    const filterSensitiveLog: (obj: CreateStackInstancesOutput) => any;
+}
+
+export interface InvalidOperationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidOperationException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface OperationIdAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "OperationIdAlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface OperationInProgressException extends __SmithyException, $MetadataBearer {
+    name: "OperationInProgressException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface StackSetNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "StackSetNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface StaleRequestException extends __SmithyException, $MetadataBearer {
+    name: "StaleRequestException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface CreatedButModifiedException extends __SmithyException, $MetadataBearer {
+    name: "CreatedButModifiedException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface ManagedExecution {
+    
+    Active?: boolean;
+}
+export declare namespace ManagedExecution {
+    
+    const filterSensitiveLog: (obj: ManagedExecution) => any;
+}
+export declare type PermissionModels = "SELF_MANAGED" | "SERVICE_MANAGED";
+export interface CreateStackSetInput {
+    
+    StackSetName: string | undefined;
+    
+    Description?: string;
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    StackId?: string;
+    
+    Parameters?: Parameter[];
+    
+    Capabilities?: (Capability | string)[];
+    
+    Tags?: Tag[];
+    
+    AdministrationRoleARN?: string;
+    
+    ExecutionRoleName?: string;
+    
+    PermissionModel?: PermissionModels | string;
+    
+    AutoDeployment?: AutoDeployment;
+    
+    CallAs?: CallAs | string;
+    
+    ClientRequestToken?: string;
+    
+    ManagedExecution?: ManagedExecution;
+}
+export declare namespace CreateStackSetInput {
+    
+    const filterSensitiveLog: (obj: CreateStackSetInput) => any;
+}
+export interface CreateStackSetOutput {
+    
+    StackSetId?: string;
+}
+export declare namespace CreateStackSetOutput {
+    
+    const filterSensitiveLog: (obj: CreateStackSetOutput) => any;
+}
+
+export interface NameAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "NameAlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+}
+export interface DeactivateTypeInput {
+    
+    TypeName?: string;
+    
+    Type?: ThirdPartyType | string;
+    
+    Arn?: string;
+}
+export declare namespace DeactivateTypeInput {
+    
+    const filterSensitiveLog: (obj: DeactivateTypeInput) => any;
+}
+export interface DeactivateTypeOutput {
+}
+export declare namespace DeactivateTypeOutput {
+    
+    const filterSensitiveLog: (obj: DeactivateTypeOutput) => any;
+}
+
+export interface DeleteChangeSetInput {
+    
+    ChangeSetName: string | undefined;
+    
+    StackName?: string;
+}
+export declare namespace DeleteChangeSetInput {
+    
+    const filterSensitiveLog: (obj: DeleteChangeSetInput) => any;
+}
+
+export interface DeleteChangeSetOutput {
+}
+export declare namespace DeleteChangeSetOutput {
+    
+    const filterSensitiveLog: (obj: DeleteChangeSetOutput) => any;
+}
+
+export interface InvalidChangeSetStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidChangeSetStatusException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface DeleteStackInput {
+    
+    StackName: string | undefined;
+    
+    RetainResources?: string[];
+    
+    RoleARN?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace DeleteStackInput {
+    
+    const filterSensitiveLog: (obj: DeleteStackInput) => any;
+}
+export interface DeleteStackInstancesInput {
+    
+    StackSetName: string | undefined;
+    
+    Accounts?: string[];
+    
+    DeploymentTargets?: DeploymentTargets;
+    
+    Regions: string[] | undefined;
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    RetainStacks: boolean | undefined;
+    
+    OperationId?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace DeleteStackInstancesInput {
+    
+    const filterSensitiveLog: (obj: DeleteStackInstancesInput) => any;
+}
+export interface DeleteStackInstancesOutput {
+    
+    OperationId?: string;
+}
+export declare namespace DeleteStackInstancesOutput {
+    
+    const filterSensitiveLog: (obj: DeleteStackInstancesOutput) => any;
+}
+export interface DeleteStackSetInput {
+    
+    StackSetName: string | undefined;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace DeleteStackSetInput {
+    
+    const filterSensitiveLog: (obj: DeleteStackSetInput) => any;
+}
+export interface DeleteStackSetOutput {
+}
+export declare namespace DeleteStackSetOutput {
+    
+    const filterSensitiveLog: (obj: DeleteStackSetOutput) => any;
+}
+
+export interface StackSetNotEmptyException extends __SmithyException, $MetadataBearer {
+    name: "StackSetNotEmptyException";
+    $fault: "client";
+    Message?: string;
+}
+export declare type RegistryType = "MODULE" | "RESOURCE";
+export interface DeregisterTypeInput {
+    
+    Arn?: string;
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    VersionId?: string;
+}
+export declare namespace DeregisterTypeInput {
+    
+    const filterSensitiveLog: (obj: DeregisterTypeInput) => any;
+}
+export interface DeregisterTypeOutput {
+}
+export declare namespace DeregisterTypeOutput {
+    
+    const filterSensitiveLog: (obj: DeregisterTypeOutput) => any;
+}
+
+export interface DescribeAccountLimitsInput {
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAccountLimitsInput {
+    
+    const filterSensitiveLog: (obj: DescribeAccountLimitsInput) => any;
+}
+
+export interface DescribeAccountLimitsOutput {
+    
+    AccountLimits?: AccountLimit[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAccountLimitsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeAccountLimitsOutput) => any;
+}
+
+export interface DescribeChangeSetInput {
+    
+    ChangeSetName: string | undefined;
+    
+    StackName?: string;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeChangeSetInput {
+    
+    const filterSensitiveLog: (obj: DescribeChangeSetInput) => any;
+}
+
+export interface DescribeChangeSetOutput {
+    
+    ChangeSetName?: string;
+    
+    ChangeSetId?: string;
+    
+    StackId?: string;
+    
+    StackName?: string;
+    
+    Description?: string;
+    
+    Parameters?: Parameter[];
+    
+    CreationTime?: Date;
+    
+    ExecutionStatus?: ExecutionStatus | string;
+    
+    Status?: ChangeSetStatus | string;
+    
+    StatusReason?: string;
+    
+    NotificationARNs?: string[];
+    
+    RollbackConfiguration?: RollbackConfiguration;
+    
+    Capabilities?: (Capability | string)[];
+    
+    Tags?: Tag[];
+    
+    Changes?: Change[];
+    
+    NextToken?: string;
+    
+    IncludeNestedStacks?: boolean;
+    
+    ParentChangeSetId?: string;
+    
+    RootChangeSetId?: string;
+}
+export declare namespace DescribeChangeSetOutput {
+    
+    const filterSensitiveLog: (obj: DescribeChangeSetOutput) => any;
+}
+export interface DescribePublisherInput {
+    
+    PublisherId?: string;
+}
+export declare namespace DescribePublisherInput {
+    
+    const filterSensitiveLog: (obj: DescribePublisherInput) => any;
+}
+export declare enum IdentityProvider {
+    AWS_Marketplace = "AWS_Marketplace",
+    Bitbucket = "Bitbucket",
+    GitHub = "GitHub"
+}
+export declare enum PublisherStatus {
+    UNVERIFIED = "UNVERIFIED",
+    VERIFIED = "VERIFIED"
+}
+export interface DescribePublisherOutput {
+    
+    PublisherId?: string;
+    
+    PublisherStatus?: PublisherStatus | string;
+    
+    IdentityProvider?: IdentityProvider | string;
+    
+    PublisherProfile?: string;
+}
+export declare namespace DescribePublisherOutput {
+    
+    const filterSensitiveLog: (obj: DescribePublisherOutput) => any;
+}
+export interface DescribeStackDriftDetectionStatusInput {
+    
+    StackDriftDetectionId: string | undefined;
+}
+export declare namespace DescribeStackDriftDetectionStatusInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackDriftDetectionStatusInput) => any;
+}
+export declare enum StackDriftDetectionStatus {
+    DETECTION_COMPLETE = "DETECTION_COMPLETE",
+    DETECTION_FAILED = "DETECTION_FAILED",
+    DETECTION_IN_PROGRESS = "DETECTION_IN_PROGRESS"
+}
+export declare enum StackDriftStatus {
+    DRIFTED = "DRIFTED",
+    IN_SYNC = "IN_SYNC",
+    NOT_CHECKED = "NOT_CHECKED",
+    UNKNOWN = "UNKNOWN"
+}
+export interface DescribeStackDriftDetectionStatusOutput {
+    
+    StackId: string | undefined;
+    
+    StackDriftDetectionId: string | undefined;
+    
+    StackDriftStatus?: StackDriftStatus | string;
+    
+    DetectionStatus: StackDriftDetectionStatus | string | undefined;
+    
+    DetectionStatusReason?: string;
+    
+    DriftedStackResourceCount?: number;
+    
+    Timestamp: Date | undefined;
+}
+export declare namespace DescribeStackDriftDetectionStatusOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackDriftDetectionStatusOutput) => any;
+}
+
+export interface DescribeStackEventsInput {
+    
+    StackName?: string;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStackEventsInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackEventsInput) => any;
+}
+export declare enum ResourceStatus {
+    CREATE_COMPLETE = "CREATE_COMPLETE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETE_COMPLETE = "DELETE_COMPLETE",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    DELETE_SKIPPED = "DELETE_SKIPPED",
+    IMPORT_COMPLETE = "IMPORT_COMPLETE",
+    IMPORT_FAILED = "IMPORT_FAILED",
+    IMPORT_IN_PROGRESS = "IMPORT_IN_PROGRESS",
+    IMPORT_ROLLBACK_COMPLETE = "IMPORT_ROLLBACK_COMPLETE",
+    IMPORT_ROLLBACK_FAILED = "IMPORT_ROLLBACK_FAILED",
+    IMPORT_ROLLBACK_IN_PROGRESS = "IMPORT_ROLLBACK_IN_PROGRESS",
+    ROLLBACK_COMPLETE = "ROLLBACK_COMPLETE",
+    ROLLBACK_FAILED = "ROLLBACK_FAILED",
+    ROLLBACK_IN_PROGRESS = "ROLLBACK_IN_PROGRESS",
+    UPDATE_COMPLETE = "UPDATE_COMPLETE",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS",
+    UPDATE_ROLLBACK_COMPLETE = "UPDATE_ROLLBACK_COMPLETE",
+    UPDATE_ROLLBACK_FAILED = "UPDATE_ROLLBACK_FAILED",
+    UPDATE_ROLLBACK_IN_PROGRESS = "UPDATE_ROLLBACK_IN_PROGRESS"
+}
+
+export interface StackEvent {
+    
+    StackId: string | undefined;
+    
+    EventId: string | undefined;
+    
+    StackName: string | undefined;
+    
+    LogicalResourceId?: string;
+    
+    PhysicalResourceId?: string;
+    
+    ResourceType?: string;
+    
+    Timestamp: Date | undefined;
+    
+    ResourceStatus?: ResourceStatus | string;
+    
+    ResourceStatusReason?: string;
+    
+    ResourceProperties?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace StackEvent {
+    
+    const filterSensitiveLog: (obj: StackEvent) => any;
+}
+
+export interface DescribeStackEventsOutput {
+    
+    StackEvents?: StackEvent[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStackEventsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackEventsOutput) => any;
+}
+export interface DescribeStackInstanceInput {
+    
+    StackSetName: string | undefined;
+    
+    StackInstanceAccount: string | undefined;
+    
+    StackInstanceRegion: string | undefined;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace DescribeStackInstanceInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackInstanceInput) => any;
+}
+export declare type StackInstanceDetailedStatus = "CANCELLED" | "FAILED" | "INOPERABLE" | "PENDING" | "RUNNING" | "SUCCEEDED";
+
+export interface StackInstanceComprehensiveStatus {
+    
+    DetailedStatus?: StackInstanceDetailedStatus | string;
+}
+export declare namespace StackInstanceComprehensiveStatus {
+    
+    const filterSensitiveLog: (obj: StackInstanceComprehensiveStatus) => any;
+}
+export declare type StackInstanceStatus = "CURRENT" | "INOPERABLE" | "OUTDATED";
+
+export interface StackInstance {
+    
+    StackSetId?: string;
+    
+    Region?: string;
+    
+    Account?: string;
+    
+    StackId?: string;
+    
+    ParameterOverrides?: Parameter[];
+    
+    Status?: StackInstanceStatus | string;
+    
+    StackInstanceStatus?: StackInstanceComprehensiveStatus;
+    
+    StatusReason?: string;
+    
+    OrganizationalUnitId?: string;
+    
+    DriftStatus?: StackDriftStatus | string;
+    
+    LastDriftCheckTimestamp?: Date;
+}
+export declare namespace StackInstance {
+    
+    const filterSensitiveLog: (obj: StackInstance) => any;
+}
+export interface DescribeStackInstanceOutput {
+    
+    StackInstance?: StackInstance;
+}
+export declare namespace DescribeStackInstanceOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackInstanceOutput) => any;
+}
+
+export interface StackInstanceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "StackInstanceNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface DescribeStackResourceInput {
+    
+    StackName: string | undefined;
+    
+    LogicalResourceId: string | undefined;
+}
+export declare namespace DescribeStackResourceInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackResourceInput) => any;
+}
+export declare enum StackResourceDriftStatus {
+    DELETED = "DELETED",
+    IN_SYNC = "IN_SYNC",
+    MODIFIED = "MODIFIED",
+    NOT_CHECKED = "NOT_CHECKED"
+}
+
+export interface StackResourceDriftInformation {
+    
+    StackResourceDriftStatus: StackResourceDriftStatus | string | undefined;
+    
+    LastCheckTimestamp?: Date;
+}
+export declare namespace StackResourceDriftInformation {
+    
+    const filterSensitiveLog: (obj: StackResourceDriftInformation) => any;
+}
+
+export interface StackResourceDetail {
+    
+    StackName?: string;
+    
+    StackId?: string;
+    
+    LogicalResourceId: string | undefined;
+    
+    PhysicalResourceId?: string;
+    
+    ResourceType: string | undefined;
+    
+    LastUpdatedTimestamp: Date | undefined;
+    
+    ResourceStatus: ResourceStatus | string | undefined;
+    
+    ResourceStatusReason?: string;
+    
+    Description?: string;
+    
+    Metadata?: string;
+    
+    DriftInformation?: StackResourceDriftInformation;
+    
+    ModuleInfo?: ModuleInfo;
+}
+export declare namespace StackResourceDetail {
+    
+    const filterSensitiveLog: (obj: StackResourceDetail) => any;
+}
+
+export interface DescribeStackResourceOutput {
+    
+    StackResourceDetail?: StackResourceDetail;
+}
+export declare namespace DescribeStackResourceOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackResourceOutput) => any;
+}
+export interface DescribeStackResourceDriftsInput {
+    
+    StackName: string | undefined;
+    
+    StackResourceDriftStatusFilters?: (StackResourceDriftStatus | string)[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeStackResourceDriftsInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackResourceDriftsInput) => any;
+}
+
+export interface PhysicalResourceIdContextKeyValuePair {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace PhysicalResourceIdContextKeyValuePair {
+    
+    const filterSensitiveLog: (obj: PhysicalResourceIdContextKeyValuePair) => any;
+}
+export declare enum DifferenceType {
+    ADD = "ADD",
+    NOT_EQUAL = "NOT_EQUAL",
+    REMOVE = "REMOVE"
+}
+
+export interface PropertyDifference {
+    
+    PropertyPath: string | undefined;
+    
+    ExpectedValue: string | undefined;
+    
+    ActualValue: string | undefined;
+    
+    DifferenceType: DifferenceType | string | undefined;
+}
+export declare namespace PropertyDifference {
+    
+    const filterSensitiveLog: (obj: PropertyDifference) => any;
+}
+
+export interface StackResourceDrift {
+    
+    StackId: string | undefined;
+    
+    LogicalResourceId: string | undefined;
+    
+    PhysicalResourceId?: string;
+    
+    PhysicalResourceIdContext?: PhysicalResourceIdContextKeyValuePair[];
+    
+    ResourceType: string | undefined;
+    
+    ExpectedProperties?: string;
+    
+    ActualProperties?: string;
+    
+    PropertyDifferences?: PropertyDifference[];
+    
+    StackResourceDriftStatus: StackResourceDriftStatus | string | undefined;
+    
+    Timestamp: Date | undefined;
+    
+    ModuleInfo?: ModuleInfo;
+}
+export declare namespace StackResourceDrift {
+    
+    const filterSensitiveLog: (obj: StackResourceDrift) => any;
+}
+export interface DescribeStackResourceDriftsOutput {
+    
+    StackResourceDrifts: StackResourceDrift[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStackResourceDriftsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackResourceDriftsOutput) => any;
+}
+
+export interface DescribeStackResourcesInput {
+    
+    StackName?: string;
+    
+    LogicalResourceId?: string;
+    
+    PhysicalResourceId?: string;
+}
+export declare namespace DescribeStackResourcesInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackResourcesInput) => any;
+}
+
+export interface StackResource {
+    
+    StackName?: string;
+    
+    StackId?: string;
+    
+    LogicalResourceId: string | undefined;
+    
+    PhysicalResourceId?: string;
+    
+    ResourceType: string | undefined;
+    
+    Timestamp: Date | undefined;
+    
+    ResourceStatus: ResourceStatus | string | undefined;
+    
+    ResourceStatusReason?: string;
+    
+    Description?: string;
+    
+    DriftInformation?: StackResourceDriftInformation;
+    
+    ModuleInfo?: ModuleInfo;
+}
+export declare namespace StackResource {
+    
+    const filterSensitiveLog: (obj: StackResource) => any;
+}
+
+export interface DescribeStackResourcesOutput {
+    
+    StackResources?: StackResource[];
+}
+export declare namespace DescribeStackResourcesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackResourcesOutput) => any;
+}
+
+export interface DescribeStacksInput {
+    
+    StackName?: string;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStacksInput {
+    
+    const filterSensitiveLog: (obj: DescribeStacksInput) => any;
+}
+
+export interface StackDriftInformation {
+    
+    StackDriftStatus: StackDriftStatus | string | undefined;
+    
+    LastCheckTimestamp?: Date;
+}
+export declare namespace StackDriftInformation {
+    
+    const filterSensitiveLog: (obj: StackDriftInformation) => any;
+}
+
+export interface Output {
+    
+    OutputKey?: string;
+    
+    OutputValue?: string;
+    
+    Description?: string;
+    
+    ExportName?: string;
+}
+export declare namespace Output {
+    
+    const filterSensitiveLog: (obj: Output) => any;
+}
+export declare enum StackStatus {
+    CREATE_COMPLETE = "CREATE_COMPLETE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETE_COMPLETE = "DELETE_COMPLETE",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    IMPORT_COMPLETE = "IMPORT_COMPLETE",
+    IMPORT_IN_PROGRESS = "IMPORT_IN_PROGRESS",
+    IMPORT_ROLLBACK_COMPLETE = "IMPORT_ROLLBACK_COMPLETE",
+    IMPORT_ROLLBACK_FAILED = "IMPORT_ROLLBACK_FAILED",
+    IMPORT_ROLLBACK_IN_PROGRESS = "IMPORT_ROLLBACK_IN_PROGRESS",
+    REVIEW_IN_PROGRESS = "REVIEW_IN_PROGRESS",
+    ROLLBACK_COMPLETE = "ROLLBACK_COMPLETE",
+    ROLLBACK_FAILED = "ROLLBACK_FAILED",
+    ROLLBACK_IN_PROGRESS = "ROLLBACK_IN_PROGRESS",
+    UPDATE_COMPLETE = "UPDATE_COMPLETE",
+    UPDATE_COMPLETE_CLEANUP_IN_PROGRESS = "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS",
+    UPDATE_ROLLBACK_COMPLETE = "UPDATE_ROLLBACK_COMPLETE",
+    UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS = "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
+    UPDATE_ROLLBACK_FAILED = "UPDATE_ROLLBACK_FAILED",
+    UPDATE_ROLLBACK_IN_PROGRESS = "UPDATE_ROLLBACK_IN_PROGRESS"
+}
+
+export interface Stack {
+    
+    StackId?: string;
+    
+    StackName: string | undefined;
+    
+    ChangeSetId?: string;
+    
+    Description?: string;
+    
+    Parameters?: Parameter[];
+    
+    CreationTime: Date | undefined;
+    
+    DeletionTime?: Date;
+    
+    LastUpdatedTime?: Date;
+    
+    RollbackConfiguration?: RollbackConfiguration;
+    
+    StackStatus: StackStatus | string | undefined;
+    
+    StackStatusReason?: string;
+    
+    DisableRollback?: boolean;
+    
+    NotificationARNs?: string[];
+    
+    TimeoutInMinutes?: number;
+    
+    Capabilities?: (Capability | string)[];
+    
+    Outputs?: Output[];
+    
+    RoleARN?: string;
+    
+    Tags?: Tag[];
+    
+    EnableTerminationProtection?: boolean;
+    
+    ParentId?: string;
+    
+    RootId?: string;
+    
+    DriftInformation?: StackDriftInformation;
+}
+export declare namespace Stack {
+    
+    const filterSensitiveLog: (obj: Stack) => any;
+}
+
+export interface DescribeStacksOutput {
+    
+    Stacks?: Stack[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStacksOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStacksOutput) => any;
+}
+export interface DescribeStackSetInput {
+    
+    StackSetName: string | undefined;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace DescribeStackSetInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackSetInput) => any;
+}
+export declare enum StackSetDriftDetectionStatus {
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    PARTIAL_SUCCESS = "PARTIAL_SUCCESS",
+    STOPPED = "STOPPED"
+}
+export declare enum StackSetDriftStatus {
+    DRIFTED = "DRIFTED",
+    IN_SYNC = "IN_SYNC",
+    NOT_CHECKED = "NOT_CHECKED"
+}
+
+export interface StackSetDriftDetectionDetails {
+    
+    DriftStatus?: StackSetDriftStatus | string;
+    
+    DriftDetectionStatus?: StackSetDriftDetectionStatus | string;
+    
+    LastDriftCheckTimestamp?: Date;
+    
+    TotalStackInstancesCount?: number;
+    
+    DriftedStackInstancesCount?: number;
+    
+    InSyncStackInstancesCount?: number;
+    
+    InProgressStackInstancesCount?: number;
+    
+    FailedStackInstancesCount?: number;
+}
+export declare namespace StackSetDriftDetectionDetails {
+    
+    const filterSensitiveLog: (obj: StackSetDriftDetectionDetails) => any;
+}
+export declare type StackSetStatus = "ACTIVE" | "DELETED";
+
+export interface StackSet {
+    
+    StackSetName?: string;
+    
+    StackSetId?: string;
+    
+    Description?: string;
+    
+    Status?: StackSetStatus | string;
+    
+    TemplateBody?: string;
+    
+    Parameters?: Parameter[];
+    
+    Capabilities?: (Capability | string)[];
+    
+    Tags?: Tag[];
+    
+    StackSetARN?: string;
+    
+    AdministrationRoleARN?: string;
+    
+    ExecutionRoleName?: string;
+    
+    StackSetDriftDetectionDetails?: StackSetDriftDetectionDetails;
+    
+    AutoDeployment?: AutoDeployment;
+    
+    PermissionModel?: PermissionModels | string;
+    
+    OrganizationalUnitIds?: string[];
+    
+    ManagedExecution?: ManagedExecution;
+}
+export declare namespace StackSet {
+    
+    const filterSensitiveLog: (obj: StackSet) => any;
+}
+export interface DescribeStackSetOutput {
+    
+    StackSet?: StackSet;
+}
+export declare namespace DescribeStackSetOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackSetOutput) => any;
+}
+export interface DescribeStackSetOperationInput {
+    
+    StackSetName: string | undefined;
+    
+    OperationId: string | undefined;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace DescribeStackSetOperationInput {
+    
+    const filterSensitiveLog: (obj: DescribeStackSetOperationInput) => any;
+}
+export declare type StackSetOperationAction = "CREATE" | "DELETE" | "DETECT_DRIFT" | "UPDATE";
+export declare type StackSetOperationStatus = "FAILED" | "QUEUED" | "RUNNING" | "STOPPED" | "STOPPING" | "SUCCEEDED";
+
+export interface StackSetOperation {
+    
+    OperationId?: string;
+    
+    StackSetId?: string;
+    
+    Action?: StackSetOperationAction | string;
+    
+    Status?: StackSetOperationStatus | string;
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    RetainStacks?: boolean;
+    
+    AdministrationRoleARN?: string;
+    
+    ExecutionRoleName?: string;
+    
+    CreationTimestamp?: Date;
+    
+    EndTimestamp?: Date;
+    
+    DeploymentTargets?: DeploymentTargets;
+    
+    StackSetDriftDetectionDetails?: StackSetDriftDetectionDetails;
+}
+export declare namespace StackSetOperation {
+    
+    const filterSensitiveLog: (obj: StackSetOperation) => any;
+}
+export interface DescribeStackSetOperationOutput {
+    
+    StackSetOperation?: StackSetOperation;
+}
+export declare namespace DescribeStackSetOperationOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStackSetOperationOutput) => any;
+}
+
+export interface OperationNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "OperationNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export interface DescribeTypeInput {
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    Arn?: string;
+    
+    VersionId?: string;
+    
+    PublisherId?: string;
+    
+    PublicVersionNumber?: string;
+}
+export declare namespace DescribeTypeInput {
+    
+    const filterSensitiveLog: (obj: DescribeTypeInput) => any;
+}
+export declare type DeprecatedStatus = "DEPRECATED" | "LIVE";
+export declare type ProvisioningType = "FULLY_MUTABLE" | "IMMUTABLE" | "NON_PROVISIONABLE";
+
+export interface RequiredActivatedType {
+    
+    TypeNameAlias?: string;
+    
+    OriginalTypeName?: string;
+    
+    PublisherId?: string;
+    
+    SupportedMajorVersions?: number[];
+}
+export declare namespace RequiredActivatedType {
+    
+    const filterSensitiveLog: (obj: RequiredActivatedType) => any;
+}
+export declare enum TypeTestsStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    NOT_TESTED = "NOT_TESTED",
+    PASSED = "PASSED"
+}
+export declare type Visibility = "PRIVATE" | "PUBLIC";
+export interface DescribeTypeOutput {
+    
+    Arn?: string;
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    DefaultVersionId?: string;
+    
+    IsDefaultVersion?: boolean;
+    
+    TypeTestsStatus?: TypeTestsStatus | string;
+    
+    TypeTestsStatusDescription?: string;
+    
+    Description?: string;
+    
+    Schema?: string;
+    
+    ProvisioningType?: ProvisioningType | string;
+    
+    DeprecatedStatus?: DeprecatedStatus | string;
+    
+    LoggingConfig?: LoggingConfig;
+    
+    RequiredActivatedTypes?: RequiredActivatedType[];
+    
+    ExecutionRoleArn?: string;
+    
+    Visibility?: Visibility | string;
+    
+    SourceUrl?: string;
+    
+    DocumentationUrl?: string;
+    
+    LastUpdated?: Date;
+    
+    TimeCreated?: Date;
+    
+    ConfigurationSchema?: string;
+    
+    PublisherId?: string;
+    
+    OriginalTypeName?: string;
+    
+    OriginalTypeArn?: string;
+    
+    PublicVersionNumber?: string;
+    
+    LatestPublicVersion?: string;
+    
+    IsActivated?: boolean;
+    
+    AutoUpdate?: boolean;
+}
+export declare namespace DescribeTypeOutput {
+    
+    const filterSensitiveLog: (obj: DescribeTypeOutput) => any;
+}
+export interface DescribeTypeRegistrationInput {
+    
+    RegistrationToken: string | undefined;
+}
+export declare namespace DescribeTypeRegistrationInput {
+    
+    const filterSensitiveLog: (obj: DescribeTypeRegistrationInput) => any;
+}
+export declare type RegistrationStatus = "COMPLETE" | "FAILED" | "IN_PROGRESS";
+export interface DescribeTypeRegistrationOutput {
+    
+    ProgressStatus?: RegistrationStatus | string;
+    
+    Description?: string;
+    
+    TypeArn?: string;
+    
+    TypeVersionArn?: string;
+}
+export declare namespace DescribeTypeRegistrationOutput {
+    
+    const filterSensitiveLog: (obj: DescribeTypeRegistrationOutput) => any;
+}
+export interface DetectStackDriftInput {
+    
+    StackName: string | undefined;
+    
+    LogicalResourceIds?: string[];
+}
+export declare namespace DetectStackDriftInput {
+    
+    const filterSensitiveLog: (obj: DetectStackDriftInput) => any;
+}
+export interface DetectStackDriftOutput {
+    
+    StackDriftDetectionId: string | undefined;
+}
+export declare namespace DetectStackDriftOutput {
+    
+    const filterSensitiveLog: (obj: DetectStackDriftOutput) => any;
+}
+export interface DetectStackResourceDriftInput {
+    
+    StackName: string | undefined;
+    
+    LogicalResourceId: string | undefined;
+}
+export declare namespace DetectStackResourceDriftInput {
+    
+    const filterSensitiveLog: (obj: DetectStackResourceDriftInput) => any;
+}
+export interface DetectStackResourceDriftOutput {
+    
+    StackResourceDrift: StackResourceDrift | undefined;
+}
+export declare namespace DetectStackResourceDriftOutput {
+    
+    const filterSensitiveLog: (obj: DetectStackResourceDriftOutput) => any;
+}
+export interface DetectStackSetDriftInput {
+    
+    StackSetName: string | undefined;
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    OperationId?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace DetectStackSetDriftInput {
+    
+    const filterSensitiveLog: (obj: DetectStackSetDriftInput) => any;
+}
+export interface DetectStackSetDriftOutput {
+    
+    OperationId?: string;
+}
+export declare namespace DetectStackSetDriftOutput {
+    
+    const filterSensitiveLog: (obj: DetectStackSetDriftOutput) => any;
+}
+
+export interface EstimateTemplateCostInput {
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    Parameters?: Parameter[];
+}
+export declare namespace EstimateTemplateCostInput {
+    
+    const filterSensitiveLog: (obj: EstimateTemplateCostInput) => any;
+}
+
+export interface EstimateTemplateCostOutput {
+    
+    Url?: string;
+}
+export declare namespace EstimateTemplateCostOutput {
+    
+    const filterSensitiveLog: (obj: EstimateTemplateCostOutput) => any;
+}
+
+export interface ExecuteChangeSetInput {
+    
+    ChangeSetName: string | undefined;
+    
+    StackName?: string;
+    
+    ClientRequestToken?: string;
+    
+    DisableRollback?: boolean;
+}
+export declare namespace ExecuteChangeSetInput {
+    
+    const filterSensitiveLog: (obj: ExecuteChangeSetInput) => any;
+}
+
+export interface ExecuteChangeSetOutput {
+}
+export declare namespace ExecuteChangeSetOutput {
+    
+    const filterSensitiveLog: (obj: ExecuteChangeSetOutput) => any;
+}
+
+export interface GetStackPolicyInput {
+    
+    StackName: string | undefined;
+}
+export declare namespace GetStackPolicyInput {
+    
+    const filterSensitiveLog: (obj: GetStackPolicyInput) => any;
+}
+
+export interface GetStackPolicyOutput {
+    
+    StackPolicyBody?: string;
+}
+export declare namespace GetStackPolicyOutput {
+    
+    const filterSensitiveLog: (obj: GetStackPolicyOutput) => any;
+}
+export declare enum TemplateStage {
+    Original = "Original",
+    Processed = "Processed"
+}
+
+export interface GetTemplateInput {
+    
+    StackName?: string;
+    
+    ChangeSetName?: string;
+    
+    TemplateStage?: TemplateStage | string;
+}
+export declare namespace GetTemplateInput {
+    
+    const filterSensitiveLog: (obj: GetTemplateInput) => any;
+}
+
+export interface GetTemplateOutput {
+    
+    TemplateBody?: string;
+    
+    StagesAvailable?: (TemplateStage | string)[];
+}
+export declare namespace GetTemplateOutput {
+    
+    const filterSensitiveLog: (obj: GetTemplateOutput) => any;
+}
+
+export interface GetTemplateSummaryInput {
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    StackName?: string;
+    
+    StackSetName?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace GetTemplateSummaryInput {
+    
+    const filterSensitiveLog: (obj: GetTemplateSummaryInput) => any;
+}
+
+export interface ParameterConstraints {
+    
+    AllowedValues?: string[];
+}
+export declare namespace ParameterConstraints {
+    
+    const filterSensitiveLog: (obj: ParameterConstraints) => any;
+}
+
+export interface ParameterDeclaration {
+    
+    ParameterKey?: string;
+    
+    DefaultValue?: string;
+    
+    ParameterType?: string;
+    
+    NoEcho?: boolean;
+    
+    Description?: string;
+    
+    ParameterConstraints?: ParameterConstraints;
+}
+export declare namespace ParameterDeclaration {
+    
+    const filterSensitiveLog: (obj: ParameterDeclaration) => any;
+}
+
+export interface ResourceIdentifierSummary {
+    
+    ResourceType?: string;
+    
+    LogicalResourceIds?: string[];
+    
+    ResourceIdentifiers?: string[];
+}
+export declare namespace ResourceIdentifierSummary {
+    
+    const filterSensitiveLog: (obj: ResourceIdentifierSummary) => any;
+}
+
+export interface GetTemplateSummaryOutput {
+    
+    Parameters?: ParameterDeclaration[];
+    
+    Description?: string;
+    
+    Capabilities?: (Capability | string)[];
+    
+    CapabilitiesReason?: string;
+    
+    ResourceTypes?: string[];
+    
+    Version?: string;
+    
+    Metadata?: string;
+    
+    DeclaredTransforms?: string[];
+    
+    ResourceIdentifierSummaries?: ResourceIdentifierSummary[];
+}
+export declare namespace GetTemplateSummaryOutput {
+    
+    const filterSensitiveLog: (obj: GetTemplateSummaryOutput) => any;
+}
+export interface ImportStacksToStackSetInput {
+    
+    StackSetName: string | undefined;
+    
+    StackIds?: string[];
+    
+    StackIdsUrl?: string;
+    
+    OrganizationalUnitIds?: string[];
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    OperationId?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace ImportStacksToStackSetInput {
+    
+    const filterSensitiveLog: (obj: ImportStacksToStackSetInput) => any;
+}
+export interface ImportStacksToStackSetOutput {
+    
+    OperationId?: string;
+}
+export declare namespace ImportStacksToStackSetOutput {
+    
+    const filterSensitiveLog: (obj: ImportStacksToStackSetOutput) => any;
+}
+
+export interface StackNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "StackNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface ListChangeSetsInput {
+    
+    StackName: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListChangeSetsInput {
+    
+    const filterSensitiveLog: (obj: ListChangeSetsInput) => any;
+}
+
+export interface ListChangeSetsOutput {
+    
+    Summaries?: ChangeSetSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListChangeSetsOutput {
+    
+    const filterSensitiveLog: (obj: ListChangeSetsOutput) => any;
+}
+export interface ListExportsInput {
+    
+    NextToken?: string;
+}
+export declare namespace ListExportsInput {
+    
+    const filterSensitiveLog: (obj: ListExportsInput) => any;
+}
+
+export interface Export {
+    
+    ExportingStackId?: string;
+    
+    Name?: string;
+    
+    Value?: string;
+}
+export declare namespace Export {
+    
+    const filterSensitiveLog: (obj: Export) => any;
+}
+export interface ListExportsOutput {
+    
+    Exports?: Export[];
+    
+    NextToken?: string;
+}
+export declare namespace ListExportsOutput {
+    
+    const filterSensitiveLog: (obj: ListExportsOutput) => any;
+}
+export interface ListImportsInput {
+    
+    ExportName: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListImportsInput {
+    
+    const filterSensitiveLog: (obj: ListImportsInput) => any;
+}
+export interface ListImportsOutput {
+    
+    Imports?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListImportsOutput {
+    
+    const filterSensitiveLog: (obj: ListImportsOutput) => any;
+}
+export declare type StackInstanceFilterName = "DETAILED_STATUS";
+
+export interface StackInstanceFilter {
+    
+    Name?: StackInstanceFilterName | string;
+    
+    Values?: string;
+}
+export declare namespace StackInstanceFilter {
+    
+    const filterSensitiveLog: (obj: StackInstanceFilter) => any;
+}
+export interface ListStackInstancesInput {
+    
+    StackSetName: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Filters?: StackInstanceFilter[];
+    
+    StackInstanceAccount?: string;
+    
+    StackInstanceRegion?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace ListStackInstancesInput {
+    
+    const filterSensitiveLog: (obj: ListStackInstancesInput) => any;
+}
+
+export interface StackInstanceSummary {
+    
+    StackSetId?: string;
+    
+    Region?: string;
+    
+    Account?: string;
+    
+    StackId?: string;
+    
+    Status?: StackInstanceStatus | string;
+    
+    StatusReason?: string;
+    
+    StackInstanceStatus?: StackInstanceComprehensiveStatus;
+    
+    OrganizationalUnitId?: string;
+    
+    DriftStatus?: StackDriftStatus | string;
+    
+    LastDriftCheckTimestamp?: Date;
+}
+export declare namespace StackInstanceSummary {
+    
+    const filterSensitiveLog: (obj: StackInstanceSummary) => any;
+}
+export interface ListStackInstancesOutput {
+    
+    Summaries?: StackInstanceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStackInstancesOutput {
+    
+    const filterSensitiveLog: (obj: ListStackInstancesOutput) => any;
+}
+
+export interface ListStackResourcesInput {
+    
+    StackName: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListStackResourcesInput {
+    
+    const filterSensitiveLog: (obj: ListStackResourcesInput) => any;
+}
+
+export interface StackResourceDriftInformationSummary {
+    
+    StackResourceDriftStatus: StackResourceDriftStatus | string | undefined;
+    
+    LastCheckTimestamp?: Date;
+}
+export declare namespace StackResourceDriftInformationSummary {
+    
+    const filterSensitiveLog: (obj: StackResourceDriftInformationSummary) => any;
+}
+
+export interface StackResourceSummary {
+    
+    LogicalResourceId: string | undefined;
+    
+    PhysicalResourceId?: string;
+    
+    ResourceType: string | undefined;
+    
+    LastUpdatedTimestamp: Date | undefined;
+    
+    ResourceStatus: ResourceStatus | string | undefined;
+    
+    ResourceStatusReason?: string;
+    
+    DriftInformation?: StackResourceDriftInformationSummary;
+    
+    ModuleInfo?: ModuleInfo;
+}
+export declare namespace StackResourceSummary {
+    
+    const filterSensitiveLog: (obj: StackResourceSummary) => any;
+}
+
+export interface ListStackResourcesOutput {
+    
+    StackResourceSummaries?: StackResourceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStackResourcesOutput {
+    
+    const filterSensitiveLog: (obj: ListStackResourcesOutput) => any;
+}
+
+export interface ListStacksInput {
+    
+    NextToken?: string;
+    
+    StackStatusFilter?: (StackStatus | string)[];
+}
+export declare namespace ListStacksInput {
+    
+    const filterSensitiveLog: (obj: ListStacksInput) => any;
+}
+
+export interface StackDriftInformationSummary {
+    
+    StackDriftStatus: StackDriftStatus | string | undefined;
+    
+    LastCheckTimestamp?: Date;
+}
+export declare namespace StackDriftInformationSummary {
+    
+    const filterSensitiveLog: (obj: StackDriftInformationSummary) => any;
+}
+
+export interface StackSummary {
+    
+    StackId?: string;
+    
+    StackName: string | undefined;
+    
+    TemplateDescription?: string;
+    
+    CreationTime: Date | undefined;
+    
+    LastUpdatedTime?: Date;
+    
+    DeletionTime?: Date;
+    
+    StackStatus: StackStatus | string | undefined;
+    
+    StackStatusReason?: string;
+    
+    ParentId?: string;
+    
+    RootId?: string;
+    
+    DriftInformation?: StackDriftInformationSummary;
+}
+export declare namespace StackSummary {
+    
+    const filterSensitiveLog: (obj: StackSummary) => any;
+}
+
+export interface ListStacksOutput {
+    
+    StackSummaries?: StackSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStacksOutput {
+    
+    const filterSensitiveLog: (obj: ListStacksOutput) => any;
+}
+export interface ListStackSetOperationResultsInput {
+    
+    StackSetName: string | undefined;
+    
+    OperationId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace ListStackSetOperationResultsInput {
+    
+    const filterSensitiveLog: (obj: ListStackSetOperationResultsInput) => any;
+}
+export declare type StackSetOperationResultStatus = "CANCELLED" | "FAILED" | "PENDING" | "RUNNING" | "SUCCEEDED";
+
+export interface StackSetOperationResultSummary {
+    
+    Account?: string;
+    
+    Region?: string;
+    
+    Status?: StackSetOperationResultStatus | string;
+    
+    StatusReason?: string;
+    
+    AccountGateResult?: AccountGateResult;
+    
+    OrganizationalUnitId?: string;
+}
+export declare namespace StackSetOperationResultSummary {
+    
+    const filterSensitiveLog: (obj: StackSetOperationResultSummary) => any;
+}
+export interface ListStackSetOperationResultsOutput {
+    
+    Summaries?: StackSetOperationResultSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStackSetOperationResultsOutput {
+    
+    const filterSensitiveLog: (obj: ListStackSetOperationResultsOutput) => any;
+}
+export interface ListStackSetOperationsInput {
+    
+    StackSetName: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace ListStackSetOperationsInput {
+    
+    const filterSensitiveLog: (obj: ListStackSetOperationsInput) => any;
+}
+
+export interface StackSetOperationSummary {
+    
+    OperationId?: string;
+    
+    Action?: StackSetOperationAction | string;
+    
+    Status?: StackSetOperationStatus | string;
+    
+    CreationTimestamp?: Date;
+    
+    EndTimestamp?: Date;
+}
+export declare namespace StackSetOperationSummary {
+    
+    const filterSensitiveLog: (obj: StackSetOperationSummary) => any;
+}
+export interface ListStackSetOperationsOutput {
+    
+    Summaries?: StackSetOperationSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStackSetOperationsOutput {
+    
+    const filterSensitiveLog: (obj: ListStackSetOperationsOutput) => any;
+}
+export interface ListStackSetsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Status?: StackSetStatus | string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace ListStackSetsInput {
+    
+    const filterSensitiveLog: (obj: ListStackSetsInput) => any;
+}
+
+export interface StackSetSummary {
+    
+    StackSetName?: string;
+    
+    StackSetId?: string;
+    
+    Description?: string;
+    
+    Status?: StackSetStatus | string;
+    
+    AutoDeployment?: AutoDeployment;
+    
+    PermissionModel?: PermissionModels | string;
+    
+    DriftStatus?: StackDriftStatus | string;
+    
+    LastDriftCheckTimestamp?: Date;
+    
+    ManagedExecution?: ManagedExecution;
+}
+export declare namespace StackSetSummary {
+    
+    const filterSensitiveLog: (obj: StackSetSummary) => any;
+}
+export interface ListStackSetsOutput {
+    
+    Summaries?: StackSetSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStackSetsOutput {
+    
+    const filterSensitiveLog: (obj: ListStackSetsOutput) => any;
+}
+export interface ListTypeRegistrationsInput {
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    TypeArn?: string;
+    
+    RegistrationStatusFilter?: RegistrationStatus | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTypeRegistrationsInput {
+    
+    const filterSensitiveLog: (obj: ListTypeRegistrationsInput) => any;
+}
+export interface ListTypeRegistrationsOutput {
+    
+    RegistrationTokenList?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTypeRegistrationsOutput {
+    
+    const filterSensitiveLog: (obj: ListTypeRegistrationsOutput) => any;
+}
+
+export interface TypeFilters {
+    
+    Category?: Category | string;
+    
+    PublisherId?: string;
+    
+    TypeNamePrefix?: string;
+}
+export declare namespace TypeFilters {
+    
+    const filterSensitiveLog: (obj: TypeFilters) => any;
+}
+export interface ListTypesInput {
+    
+    Visibility?: Visibility | string;
+    
+    ProvisioningType?: ProvisioningType | string;
+    
+    DeprecatedStatus?: DeprecatedStatus | string;
+    
+    Type?: RegistryType | string;
+    
+    Filters?: TypeFilters;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTypesInput {
+    
+    const filterSensitiveLog: (obj: ListTypesInput) => any;
+}
+
+export interface TypeSummary {
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    DefaultVersionId?: string;
+    
+    TypeArn?: string;
+    
+    LastUpdated?: Date;
+    
+    Description?: string;
+    
+    PublisherId?: string;
+    
+    OriginalTypeName?: string;
+    
+    PublicVersionNumber?: string;
+    
+    LatestPublicVersion?: string;
+    
+    PublisherIdentity?: IdentityProvider | string;
+    
+    PublisherName?: string;
+    
+    IsActivated?: boolean;
+}
+export declare namespace TypeSummary {
+    
+    const filterSensitiveLog: (obj: TypeSummary) => any;
+}
+export interface ListTypesOutput {
+    
+    TypeSummaries?: TypeSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTypesOutput {
+    
+    const filterSensitiveLog: (obj: ListTypesOutput) => any;
+}
+export interface ListTypeVersionsInput {
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    Arn?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    DeprecatedStatus?: DeprecatedStatus | string;
+    
+    PublisherId?: string;
+}
+export declare namespace ListTypeVersionsInput {
+    
+    const filterSensitiveLog: (obj: ListTypeVersionsInput) => any;
+}
+
+export interface TypeVersionSummary {
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    VersionId?: string;
+    
+    IsDefaultVersion?: boolean;
+    
+    Arn?: string;
+    
+    TimeCreated?: Date;
+    
+    Description?: string;
+    
+    PublicVersionNumber?: string;
+}
+export declare namespace TypeVersionSummary {
+    
+    const filterSensitiveLog: (obj: TypeVersionSummary) => any;
+}
+export interface ListTypeVersionsOutput {
+    
+    TypeVersionSummaries?: TypeVersionSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTypeVersionsOutput {
+    
+    const filterSensitiveLog: (obj: ListTypeVersionsOutput) => any;
+}
+export interface PublishTypeInput {
+    
+    Type?: ThirdPartyType | string;
+    
+    Arn?: string;
+    
+    TypeName?: string;
+    
+    PublicVersionNumber?: string;
+}
+export declare namespace PublishTypeInput {
+    
+    const filterSensitiveLog: (obj: PublishTypeInput) => any;
+}
+export interface PublishTypeOutput {
+    
+    PublicTypeArn?: string;
+}
+export declare namespace PublishTypeOutput {
+    
+    const filterSensitiveLog: (obj: PublishTypeOutput) => any;
+}
+
+export interface InvalidStateTransitionException extends __SmithyException, $MetadataBearer {
+    name: "InvalidStateTransitionException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface OperationStatusCheckFailedException extends __SmithyException, $MetadataBearer {
+    name: "OperationStatusCheckFailedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum OperationStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS"
+}
+export declare enum HandlerErrorCode {
+    AccessDenied = "AccessDenied",
+    AlreadyExists = "AlreadyExists",
+    GeneralServiceException = "GeneralServiceException",
+    InternalFailure = "InternalFailure",
+    InvalidCredentials = "InvalidCredentials",
+    InvalidRequest = "InvalidRequest",
+    InvalidTypeConfiguration = "InvalidTypeConfiguration",
+    NetworkFailure = "NetworkFailure",
+    NotFound = "NotFound",
+    NotUpdatable = "NotUpdatable",
+    ResourceConflict = "ResourceConflict",
+    ServiceInternalError = "ServiceInternalError",
+    ServiceLimitExceeded = "ServiceLimitExceeded",
+    ServiceTimeout = "NotStabilized",
+    Throttling = "Throttling"
+}
+export interface RecordHandlerProgressInput {
+    
+    BearerToken: string | undefined;
+    
+    OperationStatus: OperationStatus | string | undefined;
+    
+    CurrentOperationStatus?: OperationStatus | string;
+    
+    StatusMessage?: string;
+    
+    ErrorCode?: HandlerErrorCode | string;
+    
+    ResourceModel?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace RecordHandlerProgressInput {
+    
+    const filterSensitiveLog: (obj: RecordHandlerProgressInput) => any;
+}
+export interface RecordHandlerProgressOutput {
+}
+export declare namespace RecordHandlerProgressOutput {
+    
+    const filterSensitiveLog: (obj: RecordHandlerProgressOutput) => any;
+}
+export interface RegisterPublisherInput {
+    
+    AcceptTermsAndConditions?: boolean;
+    
+    ConnectionArn?: string;
+}
+export declare namespace RegisterPublisherInput {
+    
+    const filterSensitiveLog: (obj: RegisterPublisherInput) => any;
+}
+export interface RegisterPublisherOutput {
+    
+    PublisherId?: string;
+}
+export declare namespace RegisterPublisherOutput {
+    
+    const filterSensitiveLog: (obj: RegisterPublisherOutput) => any;
+}
+export interface RegisterTypeInput {
+    
+    Type?: RegistryType | string;
+    
+    TypeName: string | undefined;
+    
+    SchemaHandlerPackage: string | undefined;
+    
+    LoggingConfig?: LoggingConfig;
+    
+    ExecutionRoleArn?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace RegisterTypeInput {
+    
+    const filterSensitiveLog: (obj: RegisterTypeInput) => any;
+}
+export interface RegisterTypeOutput {
+    
+    RegistrationToken?: string;
+}
+export declare namespace RegisterTypeOutput {
+    
+    const filterSensitiveLog: (obj: RegisterTypeOutput) => any;
+}
+export interface RollbackStackInput {
+    
+    StackName: string | undefined;
+    
+    RoleARN?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace RollbackStackInput {
+    
+    const filterSensitiveLog: (obj: RollbackStackInput) => any;
+}
+export interface RollbackStackOutput {
+    
+    StackId?: string;
+}
+export declare namespace RollbackStackOutput {
+    
+    const filterSensitiveLog: (obj: RollbackStackOutput) => any;
+}
+
+export interface SetStackPolicyInput {
+    
+    StackName: string | undefined;
+    
+    StackPolicyBody?: string;
+    
+    StackPolicyURL?: string;
+}
+export declare namespace SetStackPolicyInput {
+    
+    const filterSensitiveLog: (obj: SetStackPolicyInput) => any;
+}
+export interface SetTypeConfigurationInput {
+    
+    TypeArn?: string;
+    
+    Configuration: string | undefined;
+    
+    ConfigurationAlias?: string;
+    
+    TypeName?: string;
+    
+    Type?: ThirdPartyType | string;
+}
+export declare namespace SetTypeConfigurationInput {
+    
+    const filterSensitiveLog: (obj: SetTypeConfigurationInput) => any;
+}
+export interface SetTypeConfigurationOutput {
+    
+    ConfigurationArn?: string;
+}
+export declare namespace SetTypeConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: SetTypeConfigurationOutput) => any;
+}
+export interface SetTypeDefaultVersionInput {
+    
+    Arn?: string;
+    
+    Type?: RegistryType | string;
+    
+    TypeName?: string;
+    
+    VersionId?: string;
+}
+export declare namespace SetTypeDefaultVersionInput {
+    
+    const filterSensitiveLog: (obj: SetTypeDefaultVersionInput) => any;
+}
+export interface SetTypeDefaultVersionOutput {
+}
+export declare namespace SetTypeDefaultVersionOutput {
+    
+    const filterSensitiveLog: (obj: SetTypeDefaultVersionOutput) => any;
+}
+export declare enum ResourceSignalStatus {
+    FAILURE = "FAILURE",
+    SUCCESS = "SUCCESS"
+}
+
+export interface SignalResourceInput {
+    
+    StackName: string | undefined;
+    
+    LogicalResourceId: string | undefined;
+    
+    UniqueId: string | undefined;
+    
+    Status: ResourceSignalStatus | string | undefined;
+}
+export declare namespace SignalResourceInput {
+    
+    const filterSensitiveLog: (obj: SignalResourceInput) => any;
+}
+export interface StopStackSetOperationInput {
+    
+    StackSetName: string | undefined;
+    
+    OperationId: string | undefined;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace StopStackSetOperationInput {
+    
+    const filterSensitiveLog: (obj: StopStackSetOperationInput) => any;
+}
+export interface StopStackSetOperationOutput {
+}
+export declare namespace StopStackSetOperationOutput {
+    
+    const filterSensitiveLog: (obj: StopStackSetOperationOutput) => any;
+}
+export interface TestTypeInput {
+    
+    Arn?: string;
+    
+    Type?: ThirdPartyType | string;
+    
+    TypeName?: string;
+    
+    VersionId?: string;
+    
+    LogDeliveryBucket?: string;
+}
+export declare namespace TestTypeInput {
+    
+    const filterSensitiveLog: (obj: TestTypeInput) => any;
+}
+export interface TestTypeOutput {
+    
+    TypeVersionArn?: string;
+}
+export declare namespace TestTypeOutput {
+    
+    const filterSensitiveLog: (obj: TestTypeOutput) => any;
+}
+
+export interface UpdateStackInput {
+    
+    StackName: string | undefined;
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    UsePreviousTemplate?: boolean;
+    
+    StackPolicyDuringUpdateBody?: string;
+    
+    StackPolicyDuringUpdateURL?: string;
+    
+    Parameters?: Parameter[];
+    
+    Capabilities?: (Capability | string)[];
+    
+    ResourceTypes?: string[];
+    
+    RoleARN?: string;
+    
+    RollbackConfiguration?: RollbackConfiguration;
+    
+    StackPolicyBody?: string;
+    
+    StackPolicyURL?: string;
+    
+    NotificationARNs?: string[];
+    
+    Tags?: Tag[];
+    
+    DisableRollback?: boolean;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace UpdateStackInput {
+    
+    const filterSensitiveLog: (obj: UpdateStackInput) => any;
+}
+
+export interface UpdateStackOutput {
+    
+    StackId?: string;
+}
+export declare namespace UpdateStackOutput {
+    
+    const filterSensitiveLog: (obj: UpdateStackOutput) => any;
+}
+export interface UpdateStackInstancesInput {
+    
+    StackSetName: string | undefined;
+    
+    Accounts?: string[];
+    
+    DeploymentTargets?: DeploymentTargets;
+    
+    Regions: string[] | undefined;
+    
+    ParameterOverrides?: Parameter[];
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    OperationId?: string;
+    
+    CallAs?: CallAs | string;
+}
+export declare namespace UpdateStackInstancesInput {
+    
+    const filterSensitiveLog: (obj: UpdateStackInstancesInput) => any;
+}
+export interface UpdateStackInstancesOutput {
+    
+    OperationId?: string;
+}
+export declare namespace UpdateStackInstancesOutput {
+    
+    const filterSensitiveLog: (obj: UpdateStackInstancesOutput) => any;
+}
+export interface UpdateStackSetInput {
+    
+    StackSetName: string | undefined;
+    
+    Description?: string;
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+    
+    UsePreviousTemplate?: boolean;
+    
+    Parameters?: Parameter[];
+    
+    Capabilities?: (Capability | string)[];
+    
+    Tags?: Tag[];
+    
+    OperationPreferences?: StackSetOperationPreferences;
+    
+    AdministrationRoleARN?: string;
+    
+    ExecutionRoleName?: string;
+    
+    DeploymentTargets?: DeploymentTargets;
+    
+    PermissionModel?: PermissionModels | string;
+    
+    AutoDeployment?: AutoDeployment;
+    
+    OperationId?: string;
+    
+    Accounts?: string[];
+    
+    Regions?: string[];
+    
+    CallAs?: CallAs | string;
+    
+    ManagedExecution?: ManagedExecution;
+}
+export declare namespace UpdateStackSetInput {
+    
+    const filterSensitiveLog: (obj: UpdateStackSetInput) => any;
+}
+export interface UpdateStackSetOutput {
+    
+    OperationId?: string;
+}
+export declare namespace UpdateStackSetOutput {
+    
+    const filterSensitiveLog: (obj: UpdateStackSetOutput) => any;
+}
+export interface UpdateTerminationProtectionInput {
+    
+    EnableTerminationProtection: boolean | undefined;
+    
+    StackName: string | undefined;
+}
+export declare namespace UpdateTerminationProtectionInput {
+    
+    const filterSensitiveLog: (obj: UpdateTerminationProtectionInput) => any;
+}
+export interface UpdateTerminationProtectionOutput {
+    
+    StackId?: string;
+}
+export declare namespace UpdateTerminationProtectionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateTerminationProtectionOutput) => any;
+}
+
+export interface ValidateTemplateInput {
+    
+    TemplateBody?: string;
+    
+    TemplateURL?: string;
+}
+export declare namespace ValidateTemplateInput {
+    
+    const filterSensitiveLog: (obj: ValidateTemplateInput) => any;
+}
+
+export interface TemplateParameter {
+    
+    ParameterKey?: string;
+    
+    DefaultValue?: string;
+    
+    NoEcho?: boolean;
+    
+    Description?: string;
+}
+export declare namespace TemplateParameter {
+    
+    const filterSensitiveLog: (obj: TemplateParameter) => any;
+}
+
+export interface ValidateTemplateOutput {
+    
+    Parameters?: TemplateParameter[];
+    
+    Description?: string;
+    
+    Capabilities?: (Capability | string)[];
+    
+    CapabilitiesReason?: string;
+    
+    DeclaredTransforms?: string[];
+}
+export declare namespace ValidateTemplateOutput {
+    
+    const filterSensitiveLog: (obj: ValidateTemplateOutput) => any;
+}