# 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
from . import outputs

__all__ = [
    'AuthenticationRuleChildren',
    'AuthenticationRuleChildrenChildren',
    'AuthorizationExceptionRuleChildren',
    'AuthorizationExceptionRuleChildrenChildren',
    'AuthorizationGlobalExceptionRuleChildren',
    'AuthorizationGlobalExceptionRuleChildrenChildren',
    'AuthorizationProfileAdvancedAttribute',
    'AuthorizationRuleChildren',
    'AuthorizationRuleChildrenChildren',
    'ConditionChildren',
    'ConditionChildrenChildren',
    'PolicySetChildren',
    'PolicySetChildrenChildren',
    'GetAuthenticationRuleChildrenResult',
    'GetAuthenticationRuleChildrenChildrenResult',
    'GetAuthorizationExceptionRuleChildrenResult',
    'GetAuthorizationExceptionRuleChildrenChildrenResult',
    'GetAuthorizationGlobalExceptionRuleChildrenResult',
    'GetAuthorizationGlobalExceptionRuleChildrenChildrenResult',
    'GetAuthorizationProfileAdvancedAttributeResult',
    'GetAuthorizationRuleChildrenResult',
    'GetAuthorizationRuleChildrenChildrenResult',
    'GetConditionChildrenResult',
    'GetConditionChildrenChildrenResult',
    'GetPolicySetChildrenResult',
    'GetPolicySetChildrenChildrenResult',
]

@pulumi.output_type
class AuthenticationRuleChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthenticationRuleChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthenticationRuleChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthenticationRuleChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 childrens: Optional[Sequence['outputs.AuthenticationRuleChildrenChildren']] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param 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 builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['AuthenticationRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> 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")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthenticationRuleChildrenChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthenticationRuleChildrenChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthenticationRuleChildrenChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthenticationRuleChildrenChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param builtins.str condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> builtins.str:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthorizationExceptionRuleChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationExceptionRuleChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationExceptionRuleChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationExceptionRuleChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 childrens: Optional[Sequence['outputs.AuthorizationExceptionRuleChildrenChildren']] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param 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 builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['AuthorizationExceptionRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> 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")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthorizationExceptionRuleChildrenChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationExceptionRuleChildrenChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationExceptionRuleChildrenChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationExceptionRuleChildrenChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param builtins.str condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> builtins.str:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthorizationGlobalExceptionRuleChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationGlobalExceptionRuleChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationGlobalExceptionRuleChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationGlobalExceptionRuleChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 childrens: Optional[Sequence['outputs.AuthorizationGlobalExceptionRuleChildrenChildren']] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param 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 builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['AuthorizationGlobalExceptionRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> 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")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthorizationGlobalExceptionRuleChildrenChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationGlobalExceptionRuleChildrenChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationGlobalExceptionRuleChildrenChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationGlobalExceptionRuleChildrenChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param builtins.str condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> builtins.str:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthorizationProfileAdvancedAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attributeLeftDictionaryName":
            suggest = "attribute_left_dictionary_name"
        elif key == "attributeLeftName":
            suggest = "attribute_left_name"
        elif key == "attributeRightDictionaryName":
            suggest = "attribute_right_dictionary_name"
        elif key == "attributeRightName":
            suggest = "attribute_right_name"
        elif key == "attributeRightValue":
            suggest = "attribute_right_value"
        elif key == "attributeRightValueType":
            suggest = "attribute_right_value_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationProfileAdvancedAttribute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationProfileAdvancedAttribute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationProfileAdvancedAttribute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 attribute_left_dictionary_name: Optional[builtins.str] = None,
                 attribute_left_name: Optional[builtins.str] = None,
                 attribute_right_dictionary_name: Optional[builtins.str] = None,
                 attribute_right_name: Optional[builtins.str] = None,
                 attribute_right_value: Optional[builtins.str] = None,
                 attribute_right_value_type: Optional[builtins.str] = None):
        """
        :param builtins.str attribute_left_dictionary_name: Dictionary name
        :param builtins.str attribute_left_name: Attribute name
        :param builtins.str attribute_right_dictionary_name: Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        :param builtins.str attribute_right_name: Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        :param builtins.str attribute_right_value: Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
        :param 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[builtins.str]:
        """
        Dictionary name
        """
        return pulumi.get(self, "attribute_left_dictionary_name")

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

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

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

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

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


@pulumi.output_type
class AuthorizationRuleChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationRuleChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationRuleChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationRuleChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 childrens: Optional[Sequence['outputs.AuthorizationRuleChildrenChildren']] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param 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 builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['AuthorizationRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> 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")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class AuthorizationRuleChildrenChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AuthorizationRuleChildrenChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AuthorizationRuleChildrenChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AuthorizationRuleChildrenChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param builtins.str condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> builtins.str:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class ConditionChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ConditionChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ConditionChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ConditionChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 childrens: Optional[Sequence['outputs.ConditionChildrenChildren']] = None,
                 description: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 name: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param 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 builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['ConditionChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param builtins.str description: Condition description
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str name: Condition name
        :param 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) -> 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")

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class ConditionChildrenChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ConditionChildrenChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ConditionChildrenChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ConditionChildrenChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 description: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 name: Optional[builtins.str] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param builtins.str condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str description: Condition description
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str name: Condition name
        :param 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) -> builtins.str:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class PolicySetChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PolicySetChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PolicySetChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PolicySetChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 childrens: Optional[Sequence['outputs.PolicySetChildrenChildren']] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param 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 builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['PolicySetChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> 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")

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class PolicySetChildrenChildren(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionType":
            suggest = "condition_type"
        elif key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"
        elif key == "dictionaryName":
            suggest = "dictionary_name"
        elif key == "dictionaryValue":
            suggest = "dictionary_value"
        elif key == "isNegate":
            suggest = "is_negate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PolicySetChildrenChildren. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PolicySetChildrenChildren.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PolicySetChildrenChildren.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition_type: builtins.str,
                 attribute_name: Optional[builtins.str] = None,
                 attribute_value: Optional[builtins.str] = None,
                 dictionary_name: Optional[builtins.str] = None,
                 dictionary_value: Optional[builtins.str] = None,
                 id: Optional[builtins.str] = None,
                 is_negate: Optional[builtins.bool] = None,
                 operator: Optional[builtins.str] = None):
        """
        :param builtins.str condition_type: Condition type.
                 - Choices: `ConditionAttributes`, `ConditionReference`
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param 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) -> builtins.str:
        """
        Condition type.
          - Choices: `ConditionAttributes`, `ConditionReference`
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> Optional[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")


@pulumi.output_type
class GetAuthenticationRuleChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 childrens: Sequence['outputs.GetAuthenticationRuleChildrenChildrenResult'],
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['GetAuthenticationRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param 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.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "childrens", childrens)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> 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.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthenticationRuleChildrenChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str condition_type: Condition type.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> builtins.str:
        """
        Condition type.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthorizationExceptionRuleChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 childrens: Sequence['outputs.GetAuthorizationExceptionRuleChildrenChildrenResult'],
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['GetAuthorizationExceptionRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param 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.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "childrens", childrens)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> 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.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthorizationExceptionRuleChildrenChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str condition_type: Condition type.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> builtins.str:
        """
        Condition type.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthorizationGlobalExceptionRuleChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 childrens: Sequence['outputs.GetAuthorizationGlobalExceptionRuleChildrenChildrenResult'],
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['GetAuthorizationGlobalExceptionRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param 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.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "childrens", childrens)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> 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.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthorizationGlobalExceptionRuleChildrenChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str condition_type: Condition type.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> builtins.str:
        """
        Condition type.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthorizationProfileAdvancedAttributeResult(dict):
    def __init__(__self__, *,
                 attribute_left_dictionary_name: builtins.str,
                 attribute_left_name: builtins.str,
                 attribute_right_dictionary_name: builtins.str,
                 attribute_right_name: builtins.str,
                 attribute_right_value: builtins.str,
                 attribute_right_value_type: builtins.str):
        """
        :param builtins.str attribute_left_dictionary_name: Dictionary name
        :param builtins.str attribute_left_name: Attribute name
        :param builtins.str attribute_right_dictionary_name: Dictionary name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        :param builtins.str attribute_right_name: Attribute name, only required when `attribute_right_value_type` is `AdvancedDictionaryAttribute`
        :param builtins.str attribute_right_value: Attribute value, only required when `attribute_right_value_type` is `AttributeValue`
        :param builtins.str attribute_right_value_type: Advanced attribute value type
        """
        pulumi.set(__self__, "attribute_left_dictionary_name", attribute_left_dictionary_name)
        pulumi.set(__self__, "attribute_left_name", attribute_left_name)
        pulumi.set(__self__, "attribute_right_dictionary_name", attribute_right_dictionary_name)
        pulumi.set(__self__, "attribute_right_name", attribute_right_name)
        pulumi.set(__self__, "attribute_right_value", attribute_right_value)
        pulumi.set(__self__, "attribute_right_value_type", attribute_right_value_type)

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

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

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

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

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

    @property
    @pulumi.getter(name="attributeRightValueType")
    def attribute_right_value_type(self) -> builtins.str:
        """
        Advanced attribute value type
        """
        return pulumi.get(self, "attribute_right_value_type")


@pulumi.output_type
class GetAuthorizationRuleChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 childrens: Sequence['outputs.GetAuthorizationRuleChildrenChildrenResult'],
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['GetAuthorizationRuleChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param 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.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "childrens", childrens)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> 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.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetAuthorizationRuleChildrenChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str condition_type: Condition type.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> builtins.str:
        """
        Condition type.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetConditionChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 childrens: Sequence['outputs.GetConditionChildrenChildrenResult'],
                 condition_type: builtins.str,
                 description: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 name: builtins.str,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['GetConditionChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param 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.
        :param builtins.str description: Condition description
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str name: Condition name
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "childrens", childrens)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operator", operator)

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

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> 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.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetConditionChildrenChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 condition_type: builtins.str,
                 description: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 name: builtins.str,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str condition_type: Condition type.
        :param builtins.str description: Condition description
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str name: Condition name
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operator", operator)

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> builtins.str:
        """
        Condition type.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetPolicySetChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 childrens: Sequence['outputs.GetPolicySetChildrenChildrenResult'],
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param Sequence['GetPolicySetChildrenChildrenArgs'] childrens: List of child conditions. `condition_type` must be one of `ConditionAndBlock` or `ConditionOrBlock`.
        :param 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.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "childrens", childrens)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> 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.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class GetPolicySetChildrenChildrenResult(dict):
    def __init__(__self__, *,
                 attribute_name: builtins.str,
                 attribute_value: builtins.str,
                 condition_type: builtins.str,
                 dictionary_name: builtins.str,
                 dictionary_value: builtins.str,
                 id: builtins.str,
                 is_negate: builtins.bool,
                 operator: builtins.str):
        """
        :param builtins.str attribute_name: Dictionary attribute name
        :param builtins.str attribute_value: Attribute value for condition. Value type is specified in dictionary object.
        :param builtins.str condition_type: Condition type.
        :param builtins.str dictionary_name: Dictionary name
        :param builtins.str dictionary_value: Dictionary value
        :param builtins.str id: UUID for condition
        :param builtins.bool is_negate: Indicates whereas this condition is in negate mode
        :param builtins.str operator: Equality operator
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "dictionary_name", dictionary_name)
        pulumi.set(__self__, "dictionary_value", dictionary_value)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_negate", is_negate)
        pulumi.set(__self__, "operator", operator)

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

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

    @property
    @pulumi.getter(name="conditionType")
    def condition_type(self) -> builtins.str:
        """
        Condition type.
        """
        return pulumi.get(self, "condition_type")

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

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

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

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

    @property
    @pulumi.getter
    def operator(self) -> builtins.str:
        """
        Equality operator
        """
        return pulumi.get(self, "operator")


