# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'AuthenticationRuleChildrenArgs',
    'AuthenticationRuleChildrenArgsDict',
    'AuthenticationRuleChildrenChildrenArgs',
    'AuthenticationRuleChildrenChildrenArgsDict',
    'AuthorizationExceptionRuleChildrenArgs',
    'AuthorizationExceptionRuleChildrenArgsDict',
    'AuthorizationExceptionRuleChildrenChildrenArgs',
    'AuthorizationExceptionRuleChildrenChildrenArgsDict',
    'AuthorizationGlobalExceptionRuleChildrenArgs',
    'AuthorizationGlobalExceptionRuleChildrenArgsDict',
    'AuthorizationGlobalExceptionRuleChildrenChildrenArgs',
    'AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict',
    'AuthorizationProfileAdvancedAttributeArgs',
    'AuthorizationProfileAdvancedAttributeArgsDict',
    'AuthorizationRuleChildrenArgs',
    'AuthorizationRuleChildrenArgsDict',
    'AuthorizationRuleChildrenChildrenArgs',
    'AuthorizationRuleChildrenChildrenArgsDict',
    'ConditionChildrenArgs',
    'ConditionChildrenArgsDict',
    'ConditionChildrenChildrenArgs',
    'ConditionChildrenChildrenArgsDict',
    'PolicySetChildrenArgs',
    'PolicySetChildrenArgsDict',
    'PolicySetChildrenChildrenArgs',
    'PolicySetChildrenChildrenArgsDict',
]

MYPY = False

if not MYPY:
    class AuthenticationRuleChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgsDict']]]]
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthenticationRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthenticationRuleChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
                 - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if childrens is not None:
            pulumi.set(__self__, "childrens", childrens)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]]:
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        return pulumi.get(self, "childrens")

    @childrens.setter
    def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthenticationRuleChildrenChildrenArgs']]]]):
        pulumi.set(self, "childrens", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthenticationRuleChildrenChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthenticationRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthenticationRuleChildrenChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthorizationExceptionRuleChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgsDict']]]]
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthorizationExceptionRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationExceptionRuleChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
                 - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if childrens is not None:
            pulumi.set(__self__, "childrens", childrens)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]]:
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        return pulumi.get(self, "childrens")

    @childrens.setter
    def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationExceptionRuleChildrenChildrenArgs']]]]):
        pulumi.set(self, "childrens", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthorizationExceptionRuleChildrenChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthorizationExceptionRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationExceptionRuleChildrenChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthorizationGlobalExceptionRuleChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict']]]]
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthorizationGlobalExceptionRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationGlobalExceptionRuleChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
                 - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if childrens is not None:
            pulumi.set(__self__, "childrens", childrens)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]]:
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        return pulumi.get(self, "childrens")

    @childrens.setter
    def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationGlobalExceptionRuleChildrenChildrenArgs']]]]):
        pulumi.set(self, "childrens", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthorizationGlobalExceptionRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationGlobalExceptionRuleChildrenChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthorizationProfileAdvancedAttributeArgsDict(TypedDict):
        attribute_left_dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        attribute_left_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute name
        """
        attribute_right_dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        """
        attribute_right_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        """
        attribute_right_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
        """
        attribute_right_value_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Advanced attribute value type
          - Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
        """
elif False:
    AuthorizationProfileAdvancedAttributeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationProfileAdvancedAttributeArgs:
    def __init__(__self__, *,
                 attribute_left_dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_left_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_right_dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_right_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_right_value: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_right_value_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] attribute_left_dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] attribute_left_name: Attribute name
        :param pulumi.Input[builtins.str] attribute_right_dictionary_name: Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        :param pulumi.Input[builtins.str] attribute_right_name: Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        :param pulumi.Input[builtins.str] attribute_right_value: Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
        :param pulumi.Input[builtins.str] attribute_right_value_type: Advanced attribute value type
                 - Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
        """
        if attribute_left_dictionary_name is not None:
            pulumi.set(__self__, "attribute_left_dictionary_name", attribute_left_dictionary_name)
        if attribute_left_name is not None:
            pulumi.set(__self__, "attribute_left_name", attribute_left_name)
        if attribute_right_dictionary_name is not None:
            pulumi.set(__self__, "attribute_right_dictionary_name", attribute_right_dictionary_name)
        if attribute_right_name is not None:
            pulumi.set(__self__, "attribute_right_name", attribute_right_name)
        if attribute_right_value is not None:
            pulumi.set(__self__, "attribute_right_value", attribute_right_value)
        if attribute_right_value_type is not None:
            pulumi.set(__self__, "attribute_right_value_type", attribute_right_value_type)

    @property
    @pulumi.getter(name="attributeLeftDictionaryName")
    def attribute_left_dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "attribute_left_dictionary_name")

    @attribute_left_dictionary_name.setter
    def attribute_left_dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_left_dictionary_name", value)

    @property
    @pulumi.getter(name="attributeLeftName")
    def attribute_left_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute name
        """
        return pulumi.get(self, "attribute_left_name")

    @attribute_left_name.setter
    def attribute_left_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_left_name", value)

    @property
    @pulumi.getter(name="attributeRightDictionaryName")
    def attribute_right_dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        """
        return pulumi.get(self, "attribute_right_dictionary_name")

    @attribute_right_dictionary_name.setter
    def attribute_right_dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_right_dictionary_name", value)

    @property
    @pulumi.getter(name="attributeRightName")
    def attribute_right_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        """
        return pulumi.get(self, "attribute_right_name")

    @attribute_right_name.setter
    def attribute_right_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_right_name", value)

    @property
    @pulumi.getter(name="attributeRightValue")
    def attribute_right_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
        """
        return pulumi.get(self, "attribute_right_value")

    @attribute_right_value.setter
    def attribute_right_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_right_value", value)

    @property
    @pulumi.getter(name="attributeRightValueType")
    def attribute_right_value_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Advanced attribute value type
          - Choices: `AdvancedDictionaryAttribute`, `AttributeValue`
        """
        return pulumi.get(self, "attribute_right_value_type")

    @attribute_right_value_type.setter
    def attribute_right_value_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_right_value_type", value)


if not MYPY:
    class AuthorizationRuleChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgsDict']]]]
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthorizationRuleChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationRuleChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 childrens: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
                 - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if childrens is not None:
            pulumi.set(__self__, "childrens", childrens)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]]:
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        return pulumi.get(self, "childrens")

    @childrens.setter
    def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AuthorizationRuleChildrenChildrenArgs']]]]):
        pulumi.set(self, "childrens", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class AuthorizationRuleChildrenChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    AuthorizationRuleChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AuthorizationRuleChildrenChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class ConditionChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgsDict']]]]
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        Condition description
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        Condition name
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    ConditionChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConditionChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 childrens: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
                 - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param pulumi.Input[builtins.str] description: Condition description
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] name: Condition name
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if childrens is not None:
            pulumi.set(__self__, "childrens", childrens)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]]:
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        return pulumi.get(self, "childrens")

    @childrens.setter
    def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ConditionChildrenChildrenArgs']]]]):
        pulumi.set(self, "childrens", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Condition description
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Condition name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class ConditionChildrenChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        Condition description
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        Condition name
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    ConditionChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConditionChildrenChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[builtins.str] description: Condition description
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] name: Condition name
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Condition description
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Condition name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class PolicySetChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        childrens: NotRequired[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgsDict']]]]
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    PolicySetChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PolicySetChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 childrens: Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
                 - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if childrens is not None:
            pulumi.set(__self__, "childrens", childrens)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Indicates whether the record is the condition itself or a logical aggregation. Logical aggreation indicates that additional conditions are present under the children attribute.
          - Choices: `ConditionAndBlock`, `ConditionAttributes`, `ConditionOrBlock`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter
    def childrens(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]]:
        """
        List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        """
        return pulumi.get(self, "childrens")

    @childrens.setter
    def childrens(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PolicySetChildrenChildrenArgs']]]]):
        pulumi.set(self, "childrens", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


if not MYPY:
    class PolicySetChildrenChildrenArgsDict(TypedDict):
        condition_type: pulumi.Input[builtins.str]
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        attribute_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary attribute name
        """
        attribute_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        dictionary_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary name
        """
        dictionary_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Dictionary value
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        UUID for condition
        """
        is_negate: NotRequired[pulumi.Input[builtins.bool]]
        """
        Indicates whereas this condition is in negate mode
        """
        operator: NotRequired[pulumi.Input[builtins.str]]
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
elif False:
    PolicySetChildrenChildrenArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PolicySetChildrenChildrenArgs:
    def __init__(__self__, *,
                 condition_type: pulumi.Input[builtins.str],
                 attribute_name: Optional[pulumi.Input[builtins.str]] = None,
                 attribute_value: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_name: Optional[pulumi.Input[builtins.str]] = None,
                 dictionary_value: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 is_negate: Optional[pulumi.Input[builtins.bool]] = None,
                 operator: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param pulumi.Input[builtins.str] attribute_name: Dictionary attribute name
        :param pulumi.Input[builtins.str] attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param pulumi.Input[builtins.str] dictionary_name: Dictionary name
        :param pulumi.Input[builtins.str] dictionary_value: Dictionary value
        :param pulumi.Input[builtins.str] id: UUID for condition
        :param pulumi.Input[builtins.bool] is_negate: Indicates whereas this condition is in negate mode
        :param pulumi.Input[builtins.str] operator: Equality operator
                 - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        pulumi.set(__self__, "condition_type", condition_type)
        if attribute_name is not None:
            pulumi.set(__self__, "attribute_name", attribute_name)
        if attribute_value is not None:
            pulumi.set(__self__, "attribute_value", attribute_value)
        if dictionary_name is not None:
            pulumi.set(__self__, "dictionary_name", dictionary_name)
        if dictionary_value is not None:
            pulumi.set(__self__, "dictionary_value", dictionary_value)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if is_negate is not None:
            pulumi.set(__self__, "is_negate", is_negate)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> pulumi.Input[builtins.str]:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "condition_type", value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary attribute name
        """
        return pulumi.get(self, "attribute_name")

    @attribute_name.setter
    def attribute_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_name", value)

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Attribute value for condition. Value type is specified in dictionary object.
        """
        return pulumi.get(self, "attribute_value")

    @attribute_value.setter
    def attribute_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "attribute_value", value)

    @property
    @pulumi.getter(name="dictionaryName")
    def dictionary_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary name
        """
        return pulumi.get(self, "dictionary_name")

    @dictionary_name.setter
    def dictionary_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_name", value)

    @property
    @pulumi.getter(name="dictionaryValue")
    def dictionary_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Dictionary value
        """
        return pulumi.get(self, "dictionary_value")

    @dictionary_value.setter
    def dictionary_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "dictionary_value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        UUID for condition
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="isNegate")
    def is_negate(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Indicates whereas this condition is in negate mode
        """
        return pulumi.get(self, "is_negate")

    @is_negate.setter
    def is_negate(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "is_negate", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Equality operator
          - Choices: `contains`, `endsWith`, `equals`, `greaterOrEquals`, `greaterThan`, `in`, `ipEquals`, `ipGreaterThan`, `ipLessThan`, `ipNotEquals`, `lessOrEquals`, `lessThan`, `matches`, `notContains`, `notEndsWith`, `notEquals`, `notIn`, `notStartsWith`, `startsWith`
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "operator", value)


