com.pulumi.aws.cloudformation.inputs.StackSetInstanceOperationPreferencesArgs Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws Show documentation
A Pulumi package for creating and managing Amazon Web Services (AWS) cloud resources.
There is a newer version: 6.60.0-alpha.1731982519
// *** WARNING: this file was generated by pulumi-java-gen. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

package com.pulumi.aws.cloudformation.inputs;

import com.pulumi.core.Output;
import com.pulumi.core.annotations.Import;
import java.lang.Integer;
import java.lang.String;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nullable;


public final class StackSetInstanceOperationPreferencesArgs extends com.pulumi.resources.ResourceArgs {

    public static final StackSetInstanceOperationPreferencesArgs Empty = new StackSetInstanceOperationPreferencesArgs();

    /**
     * Specifies how the concurrency level behaves during the operation execution. Valid values are `STRICT_FAILURE_TOLERANCE` and `SOFT_FAILURE_TOLERANCE`.
     * 
     */
    @Import(name="concurrencyMode")
    private @Nullable Output concurrencyMode;

    /**
     * @return Specifies how the concurrency level behaves during the operation execution. Valid values are `STRICT_FAILURE_TOLERANCE` and `SOFT_FAILURE_TOLERANCE`.
     * 
     */
    public Optional> concurrencyMode() {
        return Optional.ofNullable(this.concurrencyMode);
    }

    /**
     * Number of accounts, per Region, for which this operation can fail before AWS CloudFormation stops the operation in that Region.
     * 
     */
    @Import(name="failureToleranceCount")
    private @Nullable Output failureToleranceCount;

    /**
     * @return Number of accounts, per Region, for which this operation can fail before AWS CloudFormation stops the operation in that Region.
     * 
     */
    public Optional> failureToleranceCount() {
        return Optional.ofNullable(this.failureToleranceCount);
    }

    /**
     * Percentage of accounts, per Region, for which this stack operation can fail before AWS CloudFormation stops the operation in that Region.
     * 
     */
    @Import(name="failureTolerancePercentage")
    private @Nullable Output failureTolerancePercentage;

    /**
     * @return Percentage of accounts, per Region, for which this stack operation can fail before AWS CloudFormation stops the operation in that Region.
     * 
     */
    public Optional> failureTolerancePercentage() {
        return Optional.ofNullable(this.failureTolerancePercentage);
    }

    /**
     * Maximum number of accounts in which to perform this operation at one time.
     * 
     */
    @Import(name="maxConcurrentCount")
    private @Nullable Output maxConcurrentCount;

    /**
     * @return Maximum number of accounts in which to perform this operation at one time.
     * 
     */
    public Optional> maxConcurrentCount() {
        return Optional.ofNullable(this.maxConcurrentCount);
    }

    /**
     * Maximum percentage of accounts in which to perform this operation at one time.
     * 
     */
    @Import(name="maxConcurrentPercentage")
    private @Nullable Output maxConcurrentPercentage;

    /**
     * @return Maximum percentage of accounts in which to perform this operation at one time.
     * 
     */
    public Optional> maxConcurrentPercentage() {
        return Optional.ofNullable(this.maxConcurrentPercentage);
    }

    /**
     * Concurrency type of deploying StackSets operations in Regions, could be in parallel or one Region at a time. Valid values are `SEQUENTIAL` and `PARALLEL`.
     * 
     */
    @Import(name="regionConcurrencyType")
    private @Nullable Output regionConcurrencyType;

    /**
     * @return Concurrency type of deploying StackSets operations in Regions, could be in parallel or one Region at a time. Valid values are `SEQUENTIAL` and `PARALLEL`.
     * 
     */
    public Optional> regionConcurrencyType() {
        return Optional.ofNullable(this.regionConcurrencyType);
    }

    /**
     * Order of the Regions in where you want to perform the stack operation.
     * 
     */
    @Import(name="regionOrders")
    private @Nullable Output> regionOrders;

    /**
     * @return Order of the Regions in where you want to perform the stack operation.
     * 
     */
    public Optional>> regionOrders() {
        return Optional.ofNullable(this.regionOrders);
    }

    private StackSetInstanceOperationPreferencesArgs() {}

    private StackSetInstanceOperationPreferencesArgs(StackSetInstanceOperationPreferencesArgs $) {
        this.concurrencyMode = $.concurrencyMode;
        this.failureToleranceCount = $.failureToleranceCount;
        this.failureTolerancePercentage = $.failureTolerancePercentage;
        this.maxConcurrentCount = $.maxConcurrentCount;
        this.maxConcurrentPercentage = $.maxConcurrentPercentage;
        this.regionConcurrencyType = $.regionConcurrencyType;
        this.regionOrders = $.regionOrders;
    }

    public static Builder builder() {
        return new Builder();
    }
    public static Builder builder(StackSetInstanceOperationPreferencesArgs defaults) {
        return new Builder(defaults);
    }

    public static final class Builder {
        private StackSetInstanceOperationPreferencesArgs $;

        public Builder() {
            $ = new StackSetInstanceOperationPreferencesArgs();
        }

        public Builder(StackSetInstanceOperationPreferencesArgs defaults) {
            $ = new StackSetInstanceOperationPreferencesArgs(Objects.requireNonNull(defaults));
        }

        /**
         * @param concurrencyMode Specifies how the concurrency level behaves during the operation execution. Valid values are `STRICT_FAILURE_TOLERANCE` and `SOFT_FAILURE_TOLERANCE`.
         * 
         * @return builder
         * 
         */
        public Builder concurrencyMode(@Nullable Output concurrencyMode) {
            $.concurrencyMode = concurrencyMode;
            return this;
        }

        /**
         * @param concurrencyMode Specifies how the concurrency level behaves during the operation execution. Valid values are `STRICT_FAILURE_TOLERANCE` and `SOFT_FAILURE_TOLERANCE`.
         * 
         * @return builder
         * 
         */
        public Builder concurrencyMode(String concurrencyMode) {
            return concurrencyMode(Output.of(concurrencyMode));
        }

        /**
         * @param failureToleranceCount Number of accounts, per Region, for which this operation can fail before AWS CloudFormation stops the operation in that Region.
         * 
         * @return builder
         * 
         */
        public Builder failureToleranceCount(@Nullable Output failureToleranceCount) {
            $.failureToleranceCount = failureToleranceCount;
            return this;
        }

        /**
         * @param failureToleranceCount Number of accounts, per Region, for which this operation can fail before AWS CloudFormation stops the operation in that Region.
         * 
         * @return builder
         * 
         */
        public Builder failureToleranceCount(Integer failureToleranceCount) {
            return failureToleranceCount(Output.of(failureToleranceCount));
        }

        /**
         * @param failureTolerancePercentage Percentage of accounts, per Region, for which this stack operation can fail before AWS CloudFormation stops the operation in that Region.
         * 
         * @return builder
         * 
         */
        public Builder failureTolerancePercentage(@Nullable Output failureTolerancePercentage) {
            $.failureTolerancePercentage = failureTolerancePercentage;
            return this;
        }

        /**
         * @param failureTolerancePercentage Percentage of accounts, per Region, for which this stack operation can fail before AWS CloudFormation stops the operation in that Region.
         * 
         * @return builder
         * 
         */
        public Builder failureTolerancePercentage(Integer failureTolerancePercentage) {
            return failureTolerancePercentage(Output.of(failureTolerancePercentage));
        }

        /**
         * @param maxConcurrentCount Maximum number of accounts in which to perform this operation at one time.
         * 
         * @return builder
         * 
         */
        public Builder maxConcurrentCount(@Nullable Output maxConcurrentCount) {
            $.maxConcurrentCount = maxConcurrentCount;
            return this;
        }

        /**
         * @param maxConcurrentCount Maximum number of accounts in which to perform this operation at one time.
         * 
         * @return builder
         * 
         */
        public Builder maxConcurrentCount(Integer maxConcurrentCount) {
            return maxConcurrentCount(Output.of(maxConcurrentCount));
        }

        /**
         * @param maxConcurrentPercentage Maximum percentage of accounts in which to perform this operation at one time.
         * 
         * @return builder
         * 
         */
        public Builder maxConcurrentPercentage(@Nullable Output maxConcurrentPercentage) {
            $.maxConcurrentPercentage = maxConcurrentPercentage;
            return this;
        }

        /**
         * @param maxConcurrentPercentage Maximum percentage of accounts in which to perform this operation at one time.
         * 
         * @return builder
         * 
         */
        public Builder maxConcurrentPercentage(Integer maxConcurrentPercentage) {
            return maxConcurrentPercentage(Output.of(maxConcurrentPercentage));
        }

        /**
         * @param regionConcurrencyType Concurrency type of deploying StackSets operations in Regions, could be in parallel or one Region at a time. Valid values are `SEQUENTIAL` and `PARALLEL`.
         * 
         * @return builder
         * 
         */
        public Builder regionConcurrencyType(@Nullable Output regionConcurrencyType) {
            $.regionConcurrencyType = regionConcurrencyType;
            return this;
        }

        /**
         * @param regionConcurrencyType Concurrency type of deploying StackSets operations in Regions, could be in parallel or one Region at a time. Valid values are `SEQUENTIAL` and `PARALLEL`.
         * 
         * @return builder
         * 
         */
        public Builder regionConcurrencyType(String regionConcurrencyType) {
            return regionConcurrencyType(Output.of(regionConcurrencyType));
        }

        /**
         * @param regionOrders Order of the Regions in where you want to perform the stack operation.
         * 
         * @return builder
         * 
         */
        public Builder regionOrders(@Nullable Output> regionOrders) {
            $.regionOrders = regionOrders;
            return this;
        }

        /**
         * @param regionOrders Order of the Regions in where you want to perform the stack operation.
         * 
         * @return builder
         * 
         */
        public Builder regionOrders(List regionOrders) {
            return regionOrders(Output.of(regionOrders));
        }

        /**
         * @param regionOrders Order of the Regions in where you want to perform the stack operation.
         * 
         * @return builder
         * 
         */
        public Builder regionOrders(String... regionOrders) {
            return regionOrders(List.of(regionOrders));
        }

        public StackSetInstanceOperationPreferencesArgs build() {
            return $;
        }
    }

}