com.pulumi.azurenative.network.inputs.RulesEngineMatchConditionArgs Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of azure-native Show documentation
A native Pulumi package for creating and managing Azure resources.
There is a newer version: 2.72.0
// *** 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.azurenative.network.inputs;

import com.pulumi.azurenative.network.enums.RulesEngineMatchVariable;
import com.pulumi.azurenative.network.enums.RulesEngineOperator;
import com.pulumi.azurenative.network.enums.Transform;
import com.pulumi.core.Either;
import com.pulumi.core.Output;
import com.pulumi.core.annotations.Import;
import com.pulumi.exceptions.MissingRequiredPropertyException;
import java.lang.Boolean;
import java.lang.String;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nullable;


/**
 * Define a match condition
 * 
 */
public final class RulesEngineMatchConditionArgs extends com.pulumi.resources.ResourceArgs {

    public static final RulesEngineMatchConditionArgs Empty = new RulesEngineMatchConditionArgs();

    /**
     * Describes if this is negate condition or not
     * 
     */
    @Import(name="negateCondition")
    private @Nullable Output negateCondition;

    /**
     * @return Describes if this is negate condition or not
     * 
     */
    public Optional> negateCondition() {
        return Optional.ofNullable(this.negateCondition);
    }

    /**
     * Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the variable with the given operator this match condition is considered a match.
     * 
     */
    @Import(name="rulesEngineMatchValue", required=true)
    private Output> rulesEngineMatchValue;

    /**
     * @return Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the variable with the given operator this match condition is considered a match.
     * 
     */
    public Output> rulesEngineMatchValue() {
        return this.rulesEngineMatchValue;
    }

    /**
     * Match Variable
     * 
     */
    @Import(name="rulesEngineMatchVariable", required=true)
    private Output> rulesEngineMatchVariable;

    /**
     * @return Match Variable
     * 
     */
    public Output> rulesEngineMatchVariable() {
        return this.rulesEngineMatchVariable;
    }

    /**
     * Describes operator to apply to the match condition.
     * 
     */
    @Import(name="rulesEngineOperator", required=true)
    private Output> rulesEngineOperator;

    /**
     * @return Describes operator to apply to the match condition.
     * 
     */
    public Output> rulesEngineOperator() {
        return this.rulesEngineOperator;
    }

    /**
     * Name of selector in RequestHeader or RequestBody to be matched
     * 
     */
    @Import(name="selector")
    private @Nullable Output selector;

    /**
     * @return Name of selector in RequestHeader or RequestBody to be matched
     * 
     */
    public Optional> selector() {
        return Optional.ofNullable(this.selector);
    }

    /**
     * List of transforms
     * 
     */
    @Import(name="transforms")
    private @Nullable Output>> transforms;

    /**
     * @return List of transforms
     * 
     */
    public Optional>>> transforms() {
        return Optional.ofNullable(this.transforms);
    }

    private RulesEngineMatchConditionArgs() {}

    private RulesEngineMatchConditionArgs(RulesEngineMatchConditionArgs $) {
        this.negateCondition = $.negateCondition;
        this.rulesEngineMatchValue = $.rulesEngineMatchValue;
        this.rulesEngineMatchVariable = $.rulesEngineMatchVariable;
        this.rulesEngineOperator = $.rulesEngineOperator;
        this.selector = $.selector;
        this.transforms = $.transforms;
    }

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

    public static final class Builder {
        private RulesEngineMatchConditionArgs $;

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

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

        /**
         * @param negateCondition Describes if this is negate condition or not
         * 
         * @return builder
         * 
         */
        public Builder negateCondition(@Nullable Output negateCondition) {
            $.negateCondition = negateCondition;
            return this;
        }

        /**
         * @param negateCondition Describes if this is negate condition or not
         * 
         * @return builder
         * 
         */
        public Builder negateCondition(Boolean negateCondition) {
            return negateCondition(Output.of(negateCondition));
        }

        /**
         * @param rulesEngineMatchValue Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the variable with the given operator this match condition is considered a match.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchValue(Output> rulesEngineMatchValue) {
            $.rulesEngineMatchValue = rulesEngineMatchValue;
            return this;
        }

        /**
         * @param rulesEngineMatchValue Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the variable with the given operator this match condition is considered a match.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchValue(List rulesEngineMatchValue) {
            return rulesEngineMatchValue(Output.of(rulesEngineMatchValue));
        }

        /**
         * @param rulesEngineMatchValue Match values to match against. The operator will apply to each value in here with OR semantics. If any of them match the variable with the given operator this match condition is considered a match.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchValue(String... rulesEngineMatchValue) {
            return rulesEngineMatchValue(List.of(rulesEngineMatchValue));
        }

        /**
         * @param rulesEngineMatchVariable Match Variable
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchVariable(Output> rulesEngineMatchVariable) {
            $.rulesEngineMatchVariable = rulesEngineMatchVariable;
            return this;
        }

        /**
         * @param rulesEngineMatchVariable Match Variable
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchVariable(Either rulesEngineMatchVariable) {
            return rulesEngineMatchVariable(Output.of(rulesEngineMatchVariable));
        }

        /**
         * @param rulesEngineMatchVariable Match Variable
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchVariable(String rulesEngineMatchVariable) {
            return rulesEngineMatchVariable(Either.ofLeft(rulesEngineMatchVariable));
        }

        /**
         * @param rulesEngineMatchVariable Match Variable
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineMatchVariable(RulesEngineMatchVariable rulesEngineMatchVariable) {
            return rulesEngineMatchVariable(Either.ofRight(rulesEngineMatchVariable));
        }

        /**
         * @param rulesEngineOperator Describes operator to apply to the match condition.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineOperator(Output> rulesEngineOperator) {
            $.rulesEngineOperator = rulesEngineOperator;
            return this;
        }

        /**
         * @param rulesEngineOperator Describes operator to apply to the match condition.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineOperator(Either rulesEngineOperator) {
            return rulesEngineOperator(Output.of(rulesEngineOperator));
        }

        /**
         * @param rulesEngineOperator Describes operator to apply to the match condition.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineOperator(String rulesEngineOperator) {
            return rulesEngineOperator(Either.ofLeft(rulesEngineOperator));
        }

        /**
         * @param rulesEngineOperator Describes operator to apply to the match condition.
         * 
         * @return builder
         * 
         */
        public Builder rulesEngineOperator(RulesEngineOperator rulesEngineOperator) {
            return rulesEngineOperator(Either.ofRight(rulesEngineOperator));
        }

        /**
         * @param selector Name of selector in RequestHeader or RequestBody to be matched
         * 
         * @return builder
         * 
         */
        public Builder selector(@Nullable Output selector) {
            $.selector = selector;
            return this;
        }

        /**
         * @param selector Name of selector in RequestHeader or RequestBody to be matched
         * 
         * @return builder
         * 
         */
        public Builder selector(String selector) {
            return selector(Output.of(selector));
        }

        /**
         * @param transforms List of transforms
         * 
         * @return builder
         * 
         */
        public Builder transforms(@Nullable Output>> transforms) {
            $.transforms = transforms;
            return this;
        }

        /**
         * @param transforms List of transforms
         * 
         * @return builder
         * 
         */
        public Builder transforms(List> transforms) {
            return transforms(Output.of(transforms));
        }

        /**
         * @param transforms List of transforms
         * 
         * @return builder
         * 
         */
        public Builder transforms(Either... transforms) {
            return transforms(List.of(transforms));
        }

        public RulesEngineMatchConditionArgs build() {
            if ($.rulesEngineMatchValue == null) {
                throw new MissingRequiredPropertyException("RulesEngineMatchConditionArgs", "rulesEngineMatchValue");
            }
            if ($.rulesEngineMatchVariable == null) {
                throw new MissingRequiredPropertyException("RulesEngineMatchConditionArgs", "rulesEngineMatchVariable");
            }
            if ($.rulesEngineOperator == null) {
                throw new MissingRequiredPropertyException("RulesEngineMatchConditionArgs", "rulesEngineOperator");
            }
            return $;
        }
    }

}